internal bool TryGetFunctionFromMetadata( string namespaceName, string functionName, out MetadataFunctionGroup functionGroup) { IList <EdmFunction> functionOverloads; if (this._perspective.TryGetFunctionByName(namespaceName, functionName, this._parserOptions.NameComparisonCaseInsensitive, out functionOverloads)) { functionGroup = new MetadataFunctionGroup(TypeResolver.GetFullName(namespaceName, functionName), functionOverloads); return(true); } functionGroup = (MetadataFunctionGroup)null; return(false); }
// <summary> // Try get function from the model using the fully qualified name. // </summary> internal bool TryGetFunctionFromMetadata(string namespaceName, string functionName, out MetadataFunctionGroup functionGroup) { IList <EdmFunction> functionMetadata; if (_perspective.TryGetFunctionByName( namespaceName, functionName, _parserOptions.NameComparisonCaseInsensitive /* ignore case */, out functionMetadata)) { functionGroup = new MetadataFunctionGroup(GetFullName(namespaceName, functionName), functionMetadata); return(true); } else { functionGroup = null; return(false); } }
private bool TryResolveEntityContainerMemberAccess( EntityContainer entityContainer, string name, out ExpressionResolution resolution) { EntitySetBase entitySetBase; EdmFunction functionImport; if (TypeResolver.Perspective.TryGetExtent( entityContainer, name, _parserOptions.NameComparisonCaseInsensitive /*ignoreCase*/, out entitySetBase)) { resolution = new ValueExpression(entitySetBase.Scan()); return(true); } else if (TypeResolver.Perspective.TryGetFunctionImport( entityContainer, name, _parserOptions.NameComparisonCaseInsensitive /*ignoreCase*/, out functionImport)) { resolution = new MetadataFunctionGroup(functionImport.FullName, new[] { functionImport }); return(true); } else { resolution = null; return(false); } }
internal MetadataMember ResolveUnqualifiedName(string name, bool partOfQualifiedName, ErrorContext errCtx) { DebugCheck.NotEmpty(name); // // In the case of Name1.Name2...NameN and if backward compatibility mode is on, then resolve Name1 as namespace only, ignore any other possible resolutions. // var resolveAsNamespaceOnly = partOfQualifiedName && _resolveLeftMostUnqualifiedNameAsNamespaceOnly; // // In the case of Name1.Name2...NameN, ignore functions while resolving Name1: functions don't have members. // var includeFunctions = !partOfQualifiedName; // // Try resolving as an inline function. // InlineFunctionGroup inlineFunctionGroup; if (!resolveAsNamespaceOnly && includeFunctions && TryGetInlineFunction(name, out inlineFunctionGroup)) { return(inlineFunctionGroup); } // // Try resolving as a namespace alias. // MetadataNamespace aliasedNamespaceImport; if (_aliasedNamespaces.TryGetValue(name, out aliasedNamespaceImport)) { return(aliasedNamespaceImport); } if (!resolveAsNamespaceOnly) { // // Try resolving as a type or functionGroup in the global namespace or as an imported member. // Throw if ambiguous. // MetadataType type = null; MetadataFunctionGroup functionGroup = null; if (!TryGetTypeFromMetadata(name, out type)) { if (includeFunctions) { // // If name looks like a multipart identifier, try resolving it in the global namespace. // Escaped multipart identifiers usually appear in views: select [NS1.NS2.Product](...) from ... // var multipart = name.Split('.'); if (multipart.Length > 1 && multipart.All(p => p.Length > 0)) { var functionName = multipart[multipart.Length - 1]; var namespaceName = name.Substring(0, name.Length - functionName.Length - 1); TryGetFunctionFromMetadata(namespaceName, functionName, out functionGroup); } } } // // Try resolving as an imported member. // MetadataNamespace importedMemberNamespace = null; foreach (var namespaceImport in _namespaces) { var fullName = GetFullName(namespaceImport.Name, name); MetadataType importedType; if (TryGetTypeFromMetadata(fullName, out importedType)) { if (type == null && functionGroup == null) { type = importedType; importedMemberNamespace = namespaceImport; } else { throw AmbiguousMetadataMemberName(errCtx, name, namespaceImport, importedMemberNamespace); } } MetadataFunctionGroup importedFunctionGroup; if (includeFunctions && TryGetFunctionFromMetadata(namespaceImport.Name, name, out importedFunctionGroup)) { if (type == null && functionGroup == null) { functionGroup = importedFunctionGroup; importedMemberNamespace = namespaceImport; } else { throw AmbiguousMetadataMemberName(errCtx, name, namespaceImport, importedMemberNamespace); } } } if (type != null) { return(type); } if (functionGroup != null) { return(functionGroup); } } // // Otherwise, resolve as a namespace. // return(new MetadataNamespace(name)); }
internal MetadataMember ResolveUnqualifiedName( string name, bool partOfQualifiedName, ErrorContext errCtx) { bool flag1 = partOfQualifiedName && this._resolveLeftMostUnqualifiedNameAsNamespaceOnly; bool flag2 = !partOfQualifiedName; InlineFunctionGroup inlineFunctionGroup; if (!flag1 && flag2 && this.TryGetInlineFunction(name, out inlineFunctionGroup)) { return((MetadataMember)inlineFunctionGroup); } MetadataNamespace metadataNamespace; if (this._aliasedNamespaces.TryGetValue(name, out metadataNamespace)) { return((MetadataMember)metadataNamespace); } if (!flag1) { MetadataType type1 = (MetadataType)null; MetadataFunctionGroup functionGroup1 = (MetadataFunctionGroup)null; if (!this.TryGetTypeFromMetadata(name, out type1) && flag2) { string[] strArray = name.Split('.'); if (strArray.Length > 1 && ((IEnumerable <string>)strArray).All <string>((Func <string, bool>)(p => p.Length > 0))) { string functionName = strArray[strArray.Length - 1]; this.TryGetFunctionFromMetadata(name.Substring(0, name.Length - functionName.Length - 1), functionName, out functionGroup1); } } MetadataNamespace ns2 = (MetadataNamespace)null; foreach (MetadataNamespace ns1 in this._namespaces) { MetadataType type2; if (this.TryGetTypeFromMetadata(TypeResolver.GetFullName(ns1.Name, name), out type2)) { if (type1 != null || functionGroup1 != null) { throw TypeResolver.AmbiguousMetadataMemberName(errCtx, name, ns1, ns2); } type1 = type2; ns2 = ns1; } MetadataFunctionGroup functionGroup2; if (flag2 && this.TryGetFunctionFromMetadata(ns1.Name, name, out functionGroup2)) { if (type1 != null || functionGroup1 != null) { throw TypeResolver.AmbiguousMetadataMemberName(errCtx, name, ns1, ns2); } functionGroup1 = functionGroup2; ns2 = ns1; } } if (type1 != null) { return((MetadataMember)type1); } if (functionGroup1 != null) { return((MetadataMember)functionGroup1); } } return((MetadataMember) new MetadataNamespace(name)); }