internal MetadataMember ResolveMetadataMemberAccess( MetadataMember metadataMember, string name, ErrorContext errCtx) { return(this.TypeResolver.ResolveMetadataMemberAccess(metadataMember, name, errCtx)); }
internal MetadataMember ResolveMetadataMemberAccess(MetadataMember qualifier, string name, ErrorContext errCtx) { var fullName = GetFullName(qualifier.Name, name); if (qualifier.MetadataMemberClass == MetadataMemberClass.Namespace) { // // Try resolving as a type. // MetadataType type; if (TryGetTypeFromMetadata(fullName, out type)) { return(type); } // // Try resolving as a function. // MetadataFunctionGroup function; if (TryGetFunctionFromMetadata(qualifier.Name, name, out function)) { return(function); } // // Otherwise, resolve as a namespace. // return(new MetadataNamespace(fullName)); } else if (qualifier.MetadataMemberClass == MetadataMemberClass.Type) { var type = (MetadataType)qualifier; if (TypeSemantics.IsEnumerationType(type.TypeUsage)) { EnumMember member; if (_perspective.TryGetEnumMember( (EnumType)type.TypeUsage.EdmType, name, _parserOptions.NameComparisonCaseInsensitive /*ignoreCase*/, out member)) { Debug.Assert(member != null, "member != null"); Debug.Assert( _parserOptions.NameComparer.Equals(name, member.Name), "_parserOptions.NameComparer.Equals(name, member.Name)"); return(new MetadataEnumMember(fullName, type.TypeUsage, member)); } else { var message = Strings.NotAMemberOfType(name, qualifier.Name); throw EntitySqlException.Create(errCtx, message, null); } } } var message1 = Strings.InvalidMetadataMemberClassResolution( qualifier.Name, qualifier.MetadataMemberClassName, MetadataNamespace.NamespaceClassName); throw EntitySqlException.Create(errCtx, message1, null); }
// <summary> // Initializes TypeResolver instance // </summary> internal TypeResolver(Perspective perspective, ParserOptions parserOptions) { DebugCheck.NotNull(perspective); _perspective = perspective; _parserOptions = parserOptions; _aliasedNamespaces = new Dictionary <string, MetadataNamespace>(parserOptions.NameComparer); _namespaces = new HashSet <MetadataNamespace>( MetadataMember.CreateMetadataMemberNameEqualityComparer(parserOptions.NameComparer)); _functionDefinitions = new Dictionary <string, List <InlineFunctionInfo> >(parserOptions.NameComparer); _includeInlineFunctions = true; _resolveLeftMostUnqualifiedNameAsNamespaceOnly = false; }
internal MetadataMember ResolveSimpleFunctionName( string name, ErrorContext errCtx) { MetadataMember metadataMember = this.TypeResolver.ResolveUnqualifiedName(name, false, errCtx); if (metadataMember.MetadataMemberClass == MetadataMemberClass.Namespace) { EntityContainer defaultContainer = this.TypeResolver.Perspective.GetDefaultContainer(); ExpressionResolution resolution; if (defaultContainer != null && this.TryResolveEntityContainerMemberAccess(defaultContainer, name, out resolution) && resolution.ExpressionClass == ExpressionResolutionClass.MetadataMember) { metadataMember = (MetadataMember)resolution; } } return(metadataMember); }
internal MetadataMember ResolveMetadataMemberAccess( MetadataMember qualifier, string name, ErrorContext errCtx) { string fullName = TypeResolver.GetFullName(qualifier.Name, name); if (qualifier.MetadataMemberClass == MetadataMemberClass.Namespace) { MetadataType type; if (this.TryGetTypeFromMetadata(fullName, out type)) { return((MetadataMember)type); } MetadataFunctionGroup functionGroup; if (this.TryGetFunctionFromMetadata(qualifier.Name, name, out functionGroup)) { return((MetadataMember)functionGroup); } return((MetadataMember) new MetadataNamespace(fullName)); } if (qualifier.MetadataMemberClass == MetadataMemberClass.Type) { MetadataType metadataType = (MetadataType)qualifier; if (TypeSemantics.IsEnumerationType(metadataType.TypeUsage)) { EnumMember outMember; if (this._perspective.TryGetEnumMember((EnumType)metadataType.TypeUsage.EdmType, name, this._parserOptions.NameComparisonCaseInsensitive, out outMember)) { return((MetadataMember) new MetadataEnumMember(fullName, metadataType.TypeUsage, outMember)); } string errorMessage = Strings.NotAMemberOfType((object)name, (object)qualifier.Name); throw EntitySqlException.Create(errCtx, errorMessage, (Exception)null); } } string errorMessage1 = Strings.InvalidMetadataMemberClassResolution((object)qualifier.Name, (object)qualifier.MetadataMemberClassName, (object)MetadataNamespace.NamespaceClassName); throw EntitySqlException.Create(errCtx, errorMessage1, (Exception)null); }
internal TypeResolver(Perspective perspective, ParserOptions parserOptions) { this._perspective = perspective; this._parserOptions = parserOptions; this._aliasedNamespaces = new Dictionary <string, MetadataNamespace>((IEqualityComparer <string>)parserOptions.NameComparer); this._namespaces = new HashSet <MetadataNamespace>((IEqualityComparer <MetadataNamespace>)MetadataMember.CreateMetadataMemberNameEqualityComparer(parserOptions.NameComparer)); this._functionDefinitions = new Dictionary <string, List <InlineFunctionInfo> >((IEqualityComparer <string>)parserOptions.NameComparer); this._includeInlineFunctions = true; this._resolveLeftMostUnqualifiedNameAsNamespaceOnly = false; }