Merge pull request #284 from gureedo/master

mganss · web-flow · commit 74feff966c4f · 2021-09-08T16:51:17.000+02:00
any attribute is not rendered if complex type extends other complex type
diff --git a/XmlSchemaClassGenerator.Tests/Compiler.cs b/XmlSchemaClassGenerator.Tests/Compiler.cs
@@ -112,7 +112,8 @@ public static Assembly GenerateFiles(string name, IEnumerable<string> files, Gen
                 CompactTypeNames = generatorPrototype.CompactTypeNames,
                 UniqueTypeNamesAcrossNamespaces = generatorPrototype.UniqueTypeNamesAcrossNamespaces,
                 CreateGeneratedCodeAttributeVersion = generatorPrototype.CreateGeneratedCodeAttributeVersion,
-                NetCoreSpecificCode = generatorPrototype.NetCoreSpecificCode
+                NetCoreSpecificCode = generatorPrototype.NetCoreSpecificCode,
+                NamingScheme = generatorPrototype.NamingScheme
             };
 
             gen.CommentLanguages.Clear();
diff --git a/XmlSchemaClassGenerator.Tests/XmlSchemaClassGenerator.Tests.csproj b/XmlSchemaClassGenerator.Tests/XmlSchemaClassGenerator.Tests.csproj
@@ -24,7 +24,7 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>
     <PackageReference Include="Glob.cs" Version="5.1.766" />
-    <PackageReference Include="Microsoft.Net.Compilers.netcore" Version="1.3.2" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.11.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
     <PackageReference Include="System.CodeDom" Version="5.0.0" />
     <PackageReference Include="System.Text.Encoding.CodePages" Version="5.0.0" />
diff --git a/XmlSchemaClassGenerator.Tests/XmlTests.cs b/XmlSchemaClassGenerator.Tests/XmlTests.cs
@@ -300,12 +300,24 @@ public void TestListWithPublicPropertySettersWithoutConstructorsSpecified()
             }
         }
 
+        public static IEnumerable<object[]> TestSimpleData() {
+            foreach (var referenceMode in new[]
+                { CodeTypeReferenceOptions.GlobalReference, /*CodeTypeReferenceOptions.GenericTypeParameter*/ })
+            foreach (var namingScheme in new[] { NamingScheme.Direct, NamingScheme.PascalCase })
+            foreach (var collectionType in new[] { typeof(Collection<>), /*typeof(Array)*/ })
+            {
+                yield return new object[] { referenceMode, namingScheme, collectionType };
+            }
+        }
 
-        [Fact, TestPriority(1)]
+
+        [Theory, TestPriority(1)]
+        [MemberData(nameof(TestSimpleData))]
         [UseCulture("en-US")]
-        public void TestSimple()
+        public void TestSimple(CodeTypeReferenceOptions referenceMode, NamingScheme namingScheme, Type collectionType)
         {
-            Compiler.Generate("Simple", SimplePattern, new Generator
+            var name = $"Simple_{referenceMode}_{namingScheme}_{collectionType}";
+            Compiler.Generate(name, SimplePattern, new Generator
             {
                 GenerateNullables = true,
                 IntegerDataType = typeof(int),
@@ -316,10 +328,13 @@ public void TestSimple()
                 GenerateInterfaces = true,
                 NamespacePrefix = "Simple",
                 GenerateDescriptionAttribute = true,
-                CodeTypeReferenceOptions = CodeTypeReferenceOptions.GlobalReference,
-                NetCoreSpecificCode = true
+                CodeTypeReferenceOptions = referenceMode,
+                NetCoreSpecificCode = true,
+                NamingScheme = namingScheme,
+                CollectionType = collectionType,
+                CollectionSettersMode = CollectionSettersMode.Public
             });
-            TestSamples("Simple", SimplePattern);
+            TestSamples(name, SimplePattern);
         }
 
         [Fact, TestPriority(1)]
diff --git a/XmlSchemaClassGenerator.Tests/xsd/simple/any.xsd b/XmlSchemaClassGenerator.Tests/xsd/simple/any.xsd
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<xs:schema id="default"
+    targetNamespace="http://tempuri.org/default.xsd"
+    elementFormDefault="qualified"
+    xmlns="http://tempuri.org/default.xsd"
+    xmlns:mstns="http://tempuri.org/default.xsd"
+    xmlns:xs="http://www.w3.org/2001/XMLSchema"
+>
+  <xs:complexType name="AnyTest_ExtendedString">
+    <xs:simpleContent>
+      <xs:extension base="xs:string">
+         <xs:anyAttribute namespace="##any" processContents="lax"/>
+      </xs:extension>
+    </xs:simpleContent>
+  </xs:complexType>
+  
+  <xs:complexType name="AnyTest_Type">
+    <xs:sequence/>
+    <xs:anyAttribute namespace="##any" processContents="lax"/>
+  </xs:complexType>
+  
+  <xs:complexType name="AnyTest_ExtendedTypeWithAnyAttr">
+    <xs:complexContent>
+      <xs:extension base="AnyTest_Type">
+        <xs:anyAttribute namespace="##any" processContents="lax"/>
+      </xs:extension>
+    </xs:complexContent>
+  </xs:complexType>
+  
+  <xs:complexType name="AnyTest_ExtendedTypeWithoutAnyAttr">
+    <xs:complexContent>
+      <xs:extension base="AnyTest_Type" />
+    </xs:complexContent>
+  </xs:complexType>    
+  
+</xs:schema>
diff --git a/XmlSchemaClassGenerator.Tests/xsd/simple/fields_ambiguity.xsd b/XmlSchemaClassGenerator.Tests/xsd/simple/fields_ambiguity.xsd
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<xs:schema id="default"
+    targetNamespace="http://tempuri.org/default.xsd"
+    elementFormDefault="qualified"
+    xmlns="http://tempuri.org/default.xsd"
+    xmlns:mstns="http://tempuri.org/default.xsd"
+    xmlns:xs="http://www.w3.org/2001/XMLSchema"
+>
+  <xs:complexType name="AmbiguityTest_Type">
+    <xs:sequence>
+      <xs:choice minOccurs="0" maxOccurs="unbounded">
+        <xs:element name="Property">
+          <xs:complexType>
+            <xs:sequence>
+              <xs:element name="Value" type="AmbiguityTest_NestedType" minOccurs="0" maxOccurs="unbounded" />
+            </xs:sequence>
+            <xs:attribute name="value" type="xs:string" use="optional" default="" />
+          </xs:complexType>
+        </xs:element>
+      </xs:choice>
+    </xs:sequence>
+  </xs:complexType>
+
+  <xs:complexType name="AmbiguityTest_NestedType">
+    <xs:attribute name="NestedItem" type="xs:string" use="required" />
+  </xs:complexType>	
+
+</xs:schema>
diff --git a/XmlSchemaClassGenerator.Tests/xsd/simple/nested_type.xsd b/XmlSchemaClassGenerator.Tests/xsd/simple/nested_type.xsd
@@ -0,0 +1,24 @@
+﻿<?xml version="1.0" encoding="UTF-8"?>
+
+<xs:schema id="default"
+    targetNamespace="http://tempuri.org/default.xsd"
+    elementFormDefault="qualified"
+    xmlns="http://tempuri.org/default.xsd"
+    xmlns:mstns="http://tempuri.org/default.xsd"
+    xmlns:xs="http://www.w3.org/2001/XMLSchema"
+>
+	   
+  <xs:complexType name="NestedTest_NestedType">
+    <xs:sequence>
+        <xs:element name="TestField" type="xs:string" />
+    </xs:sequence>
+  </xs:complexType>		   
+		   
+  <xs:complexType name="NestedTest_Type">
+    <xs:sequence>
+        <xs:element name="TestField" type="NestedTest_NestedType" minOccurs="0" maxOccurs="1" />
+        <xs:element name="TestCollectionField" type="NestedTest_NestedType" minOccurs="0" maxOccurs="unbounded" />
+    </xs:sequence>
+  </xs:complexType>
+
+</xs:schema>
diff --git a/XmlSchemaClassGenerator/CodeUtilities.cs b/XmlSchemaClassGenerator/CodeUtilities.cs
@@ -269,11 +269,6 @@ public static string GetUniqueFieldName(this TypeModel typeModel, PropertyModel
             var i = 0;
             foreach (var prop in classModel.Properties)
             {
-                if (!classModel.Configuration.EnableDataBinding && !(prop.Type is SimpleModel))
-                {
-                    continue;
-                }
-
                 if (propertyModel == prop)
                 {
                     i += 1;
@@ -399,7 +394,20 @@ public static CodeTypeReference CreateTypeReference(Type t, GeneratorConfigurati
                 return typeRef;
             }
             else
-                return new CodeTypeReference(t, conf.CodeTypeReferenceOptions);
+            {
+                var typeRef = new CodeTypeReference(t, conf.CodeTypeReferenceOptions);
+
+                foreach (var typeArg in typeRef.TypeArguments)
+                {
+                    if (typeArg is CodeTypeReference typeArgRef)
+                    {
+                        typeArgRef.Options = conf.CodeTypeReferenceOptions;
+                    }
+                }
+
+                return typeRef;
+            }
+
         }
 
         public static CodeTypeReference CreateTypeReference(string namespaceName, string typeName, GeneratorConfiguration conf)
diff --git a/XmlSchemaClassGenerator/ModelBuilder.cs b/XmlSchemaClassGenerator/ModelBuilder.cs
@@ -5,6 +5,7 @@
 using System.Xml;
 using System.Xml.Linq;
 using System.Xml.Schema;
+using System.Xml.Serialization;
 
 namespace XmlSchemaClassGenerator
 {
@@ -577,7 +578,29 @@ private TypeModel CreateTypeModel(Uri source, XmlSchemaComplexType complexType,
                 }
             }
 
+            XmlSchemaAnyAttribute anyAttribute = null;
             if (complexType.AnyAttribute != null)
+                anyAttribute = complexType.AnyAttribute;
+            else if (complexType.AttributeWildcard != null)
+            {
+                var hasAnyAttribute = true;
+                for (var baseType = complexType.BaseXmlSchemaType; baseType != null; baseType = baseType.BaseXmlSchemaType)
+                {
+                    if (baseType is not XmlSchemaComplexType baseComplexType)
+                        continue;
+
+                    if (baseComplexType.AttributeWildcard != null)
+                    {
+                        hasAnyAttribute = false;
+                        break;
+                    }
+                }
+
+                if (hasAnyAttribute)
+                    anyAttribute = complexType.AttributeWildcard;
+            }
+
+            if (anyAttribute != null)
             {
                 var property = new PropertyModel(_configuration)
                 {
@@ -589,7 +612,7 @@ private TypeModel CreateTypeModel(Uri source, XmlSchemaComplexType complexType,
                     IsAny = true
                 };
 
-                var attributeDocs = GetDocumentation(complexType.AnyAttribute);
+                var attributeDocs = GetDocumentation(anyAttribute);
                 property.Documentation.AddRange(attributeDocs);
 
                 classModel.Properties.Add(property);
diff --git a/XmlSchemaClassGenerator/TypeModel.cs b/XmlSchemaClassGenerator/TypeModel.cs
@@ -1,7 +1,6 @@
 ﻿using System;
 using System.CodeDom;
 using System.CodeDom.Compiler;
-using System.Collections;
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.Diagnostics;
@@ -172,17 +171,32 @@ protected void GenerateSerializableAttribute(CodeTypeDeclaration typeDeclaration
         public virtual CodeTypeReference GetReferenceFor(NamespaceModel referencingNamespace, bool collection = false, bool forInit = false, bool attribute = false)
         {
             string name;
+            var referencingOptions = Configuration.CodeTypeReferenceOptions;
             if (referencingNamespace == Namespace)
+            {
                 name = Name;
+                referencingOptions = CodeTypeReferenceOptions.GenericTypeParameter;
+            }
+            else if ((referencingNamespace ?? Namespace).IsAmbiguous)
+            {
+                name = string.Format("global::{0}.{1}", Namespace.Name, Name);
+                referencingOptions = CodeTypeReferenceOptions.GenericTypeParameter;
+            }
             else
-                name = string.Format("{2}{0}.{1}", Namespace.Name, Name, ((referencingNamespace ?? Namespace).IsAmbiguous ? "global::" : string.Empty));
+            {
+                name = string.Format("{0}.{1}", Namespace.Name, Name);
+            }
 
             if (collection)
             {
                 name = forInit ? SimpleModel.GetCollectionImplementationName(name, Configuration) : SimpleModel.GetCollectionDefinitionName(name, Configuration);
+                if (Configuration.CollectionType == typeof(System.Array))
+                    referencingOptions = CodeTypeReferenceOptions.GenericTypeParameter;
+                else
+                    referencingOptions = Configuration.CodeTypeReferenceOptions;
             }
 
-            return new CodeTypeReference(name, Configuration.CodeTypeReferenceOptions);
+            return new CodeTypeReference(name, referencingOptions);
         }
 
         public virtual CodeExpression GetDefaultValueFor(string defaultString, bool attribute)
@@ -1411,7 +1425,10 @@ private static string GetFullTypeName(string typeName, CodeTypeReference typeRef
                 typeRef.ArrayElementType = new CodeTypeReference(typeName);
                 typeRef.ArrayRank = 1;
             }
-            var typeOfExpr = new CodeTypeOfExpression(typeRef);
+            var typeOfExpr = new CodeTypeOfExpression(typeRef)
+            {
+                Type = { Options = CodeTypeReferenceOptions.GenericTypeParameter }
+            };
             var writer = new System.IO.StringWriter();
             CSharpProvider.GenerateCodeFromExpression(typeOfExpr, writer, new CodeGeneratorOptions());
             var fullTypeName = writer.ToString();
