Import vocabulary annotations declared in external referenced models

src/Microsoft.OData.Edm/Csdl/Semantics/CsdlSemanticsModel.cs

@@ -113,14 +113,7 @@ private CsdlSemanticsModel(CsdlModel referencedCsdlModel, IEdmDirectValueAnnotat
 
             foreach (var schema in referencedCsdlModel.Schemata)
             {
-                string schemaNamespace = schema.Namespace;
-                IEdmInclude edmInclude = referencedCsdlModel.ParentModelReferences.SelectMany(s => s.Includes).FirstOrDefault(s => s.Namespace == schemaNamespace);
-                if (edmInclude != null)
-                {
-                    this.AddSchema(schema, false /*addAnnotations*/);
-                }
-
-                // TODO: REF add annotations
+                this.AddSchemaIfReferenced(schema, referencedCsdlModel.ParentModelReferences);
             }
         }
 
@@ -531,6 +524,119 @@ private void AddSchema(CsdlSchema schema, bool addAnnotations)
         {
             CsdlSemanticsSchema schemaWrapper = new CsdlSemanticsSchema(this, schema);
             this.schemata.Add(schemaWrapper);
+
+            AddSchemaElements(schema, schemaWrapper);
+
+            if (!string.IsNullOrEmpty(schema.Alias))
+            {
+                this.SetNamespaceAlias(schema.Namespace, schema.Alias);
+            }
+
+            if (addAnnotations)
+            {
+                AddOutOfLineAnnotationsFromSchema(schema, schemaWrapper, includeAnnotationsIndex: null);
+            }
+
+            var edmVersion = this.GetEdmVersion();
+            if (edmVersion == null || edmVersion < schema.Version)
+            {
+                this.SetEdmVersion(schema.Version);
+            }
+        }
+
+        private void AddSchemaIfReferenced(CsdlSchema schema, IEnumerable<IEdmReference> parentReferences)
+        {
+            CsdlSemanticsSchema schemaWrapper = new CsdlSemanticsSchema(this, schema);
+
+            bool shouldAddSchemaElements;
+            Dictionary<string, List<IEdmIncludeAnnotations>> includeAnnotationsIndex;
+            ProcessSchemaParentReferences(schema, schemaWrapper, parentReferences, out shouldAddSchemaElements, out includeAnnotationsIndex);
+
+            if (!string.IsNullOrEmpty(schema.Alias))
+            {
+                this.SetNamespaceAlias(schema.Namespace, schema.Alias);
+            }
+
+            if (shouldAddSchemaElements)
+            {
+                AddSchemaElements(schema, schemaWrapper);
+            }
+
+            if (includeAnnotationsIndex.Count > 0)
+            {
+                AddOutOfLineAnnotationsFromSchema(schema, schemaWrapper, includeAnnotationsIndex);
+            }
+
+            if (shouldAddSchemaElements || includeAnnotationsIndex.Count > 0)
+            {
+                this.schemata.Add(schemaWrapper);
+
+                var edmVersion = this.GetEdmVersion();
+                if (edmVersion == null || edmVersion < schema.Version)
+                {
+                    this.SetEdmVersion(schema.Version);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Process the <see cref="IEdmReference"/>s of the parent model to
+        /// figure out whether the schema's types (entiy types, enums, containers, etc.) and annotations should
+        /// be imported
+        /// </summary>
+        /// <param name="schema"></param>
+        /// <param name="schemaWrapper"></param>
+        /// <param name="parentReferences"></param>
+        /// <param name="shouldAddSchemaElements">Whether schema types such entity types, operations, enums, etc. should be important</param>
+        /// <param name="includeAnnotationsIndex">Cache of the schema's out-of-line <see cref="IEdmIncludeAnnotations"/>s indexed by the term namespace</param>
+        private static void ProcessSchemaParentReferences(
+            CsdlSchema schema,
+            CsdlSemanticsSchema schemaWrapper,
+            IEnumerable<IEdmReference> parentReferences,
+            out bool shouldAddSchemaElements,
+            out Dictionary<string, List<IEdmIncludeAnnotations>> includeAnnotationsIndex)
+        {
+            string schemaNamespace = schema.Namespace;
+
+            shouldAddSchemaElements = false;
+            includeAnnotationsIndex = new Dictionary<string, List<IEdmIncludeAnnotations>>();
+
+
+            foreach (IEdmReference reference in parentReferences)
+            {
+                if (!shouldAddSchemaElements)
+                {
+                    // we should add types from this schema if there's at least
+                    // one edmx:Include that references this schema's namespace
+                    foreach (IEdmInclude include in reference.Includes)
+                    {
+                        if (include.Namespace == schemaNamespace)
+                        {
+                            shouldAddSchemaElements = true;
+                            break;
+                        }
+                    }
+                }
+
+                foreach(IEdmIncludeAnnotations includeAnnotations in reference.IncludeAnnotations)
+                {
+                    // index the edmx:IncludeAnnotations by namespace to make it
+                    // easier to filter which annotations to import with the schema
+                    string termNamespace = includeAnnotations.TermNamespace;
+                    List<IEdmIncludeAnnotations> cachedAnnotations;
+                    if (!includeAnnotationsIndex.TryGetValue(termNamespace, out cachedAnnotations))
+                    {
+                        cachedAnnotations = new List<IEdmIncludeAnnotations>();
+                        includeAnnotationsIndex[termNamespace] = cachedAnnotations;
+                    }
+
+                    cachedAnnotations.Add(includeAnnotations);
+                }
+            }
+        }
+
+        private void AddSchemaElements(CsdlSchema schema, CsdlSemanticsSchema schemaWrapper)
+        {
             foreach (IEdmSchemaType type in schemaWrapper.Types)
             {
                 CsdlSemanticsStructuredTypeDefinition structuredType = type as CsdlSemanticsStructuredTypeDefinition;
@@ -574,34 +680,69 @@ private void AddSchema(CsdlSchema schema, bool addAnnotations)
             {
                 RegisterElement(container);
             }
+        }
 
-            if (!string.IsNullOrEmpty(schema.Alias))
+        private void AddOutOfLineAnnotationsFromSchema(
+            CsdlSchema schema,
+            CsdlSemanticsSchema schemaWrapper,
+            Dictionary<string, List<IEdmIncludeAnnotations>> includeAnnotationsIndex)
+        {
+            foreach (CsdlAnnotations schemaOutOfLineAnnotations in schema.OutOfLineAnnotations)
             {
-                this.SetNamespaceAlias(schema.Namespace, schema.Alias);
+                string target = this.ReplaceAlias(schemaOutOfLineAnnotations.Target);
+
+                List<CsdlSemanticsAnnotations> annotations;
+                if (!this.outOfLineAnnotations.TryGetValue(target, out annotations))
+                {
+                    annotations = new List<CsdlSemanticsAnnotations>();
+                    this.outOfLineAnnotations[target] = annotations;
+                }
+
+                CsdlAnnotations filteredAnnotations = FilterIncludedAnnotations(schemaOutOfLineAnnotations, target, includeAnnotationsIndex);
+                annotations.Add(new CsdlSemanticsAnnotations(schemaWrapper, filteredAnnotations));
             }
+        }
 
-            if (addAnnotations)
+        private CsdlAnnotations FilterIncludedAnnotations(
+            CsdlAnnotations csdlAnnotations,
+            string target,
+            Dictionary<string, List<IEdmIncludeAnnotations>> includeAnnotationsIndex)
+        {
+            if (includeAnnotationsIndex == null)
             {
-                foreach (CsdlAnnotations schemaOutOfLineAnnotations in schema.OutOfLineAnnotations)
-                {
-                    string target = this.ReplaceAlias(schemaOutOfLineAnnotations.Target);
+                return csdlAnnotations;
+            }
 
-                    List<CsdlSemanticsAnnotations> annotations;
-                    if (!this.outOfLineAnnotations.TryGetValue(target, out annotations))
-                    {
-                        annotations = new List<CsdlSemanticsAnnotations>();
-                        this.outOfLineAnnotations[target] = annotations;
-                    }
+            var filteredAnnotations = csdlAnnotations.Annotations.Where(annotation =>
+                ShouldIncludeAnnotation(annotation, target, includeAnnotationsIndex));
+            return new CsdlAnnotations(filteredAnnotations, csdlAnnotations.Target, csdlAnnotations.Qualifier);
+        }
+
+        private bool ShouldIncludeAnnotation(
+            CsdlAnnotation annotation,
+            string target,
+            Dictionary<string, List<IEdmIncludeAnnotations>> includeAnnotationsIndex)
+        {
+            // include annotation if it matches one of the edmx:IncludeAnnotation references
+            // we check if the namespace matches, and (if applicable) also the target namespace and the qualifier
+            // see: http://docs.oasis-open.org/odata/odata-csdl-xml/v4.01/odata-csdl-xml-v4.01.html#sec_IncludedAnnotations
+
+            string qualifiedTerm = this.ReplaceAlias(annotation.Term);
+            string targetNamespace;
+            EdmUtil.TryGetNamespaceNameFromQualifiedName(target, out targetNamespace, out string baseTarget);
+            if (EdmUtil.TryGetNamespaceNameFromQualifiedName(qualifiedTerm, out string termNamespace, out string baseTerm))
+            {
+                if (includeAnnotationsIndex.TryGetValue(termNamespace, out List<IEdmIncludeAnnotations> includeAnnotations))
+                {
 
-                    annotations.Add(new CsdlSemanticsAnnotations(schemaWrapper, schemaOutOfLineAnnotations));
+                    return includeAnnotations.Any(include =>
+                        (string.IsNullOrEmpty(include.Qualifier) || annotation.Qualifier == include.Qualifier)
+                        && (string.IsNullOrEmpty(include.TargetNamespace) || targetNamespace == include.TargetNamespace));
                 }
+
             }
 
-            var edmVersion = this.GetEdmVersion();
-            if (edmVersion == null || edmVersion < schema.Version)
-            {
-                this.SetEdmVersion(schema.Version);
-            }
+            return false;
         }
     }
 }