Modify the circular detection logic for circular 'allOf' inheritance …

…so that there can again be a passing test 'ClientModelWithCircularDependencyThrowsError'.

AutoRest/Modelers/Swagger.Tests/SwaggerModelerTests.cs

@@ -185,7 +185,9 @@ public void ClientModelWithCircularDependencyThrowsError()
                 Namespace = "Test",
                 Input = Path.Combine("Swagger", "swagger-allOf-circular.json")
             });
-            Assert.Throws<ArgumentException>(() => modeler.Build());
+            var ex = Assert.Throws<InvalidOperationException>(() => modeler.Build());
+            Assert.Contains("circular", ex.Message, StringComparison.InvariantCultureIgnoreCase);
+            Assert.Contains("siamese", ex.Message, StringComparison.InvariantCultureIgnoreCase);
         }
 
         [Fact]

AutoRest/Modelers/Swagger/Properties/Resources.resx

@@ -117,6 +117,9 @@
   <resheader name="writer">
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
+  <data name="CircularBaseSchemaSet" xml:space="preserve">
+    <value>Found a type set '{0}' which is circularly defined.</value>
+  </data>
   <data name="CircularReference" xml:space="preserve">
     <value>Circular reference detected: {0}</value>
   </data>

AutoRest/Modelers/Swagger/SchemaResolver.cs

@@ -82,7 +82,9 @@ public void ExpandAllOf(Schema schema)
 
             if (schema.AllOf != null)
             {
+                CheckCircularAllOf(schema, null, null);
                 var references = schema.AllOf.Where(s => s.Reference != null).ToList();
+
                 if (references.Count == 1)
                 {
                     if (schema.Extends != null)
@@ -101,6 +103,7 @@ public void ExpandAllOf(Schema schema)
                     Properties =
                         schema.Properties
                 };
+
                 var schemaList =
                     new List<Schema>().Concat(schema.AllOf)
                         .Concat(new List<Schema> {propertiesOnlySchema});
@@ -170,6 +173,34 @@ public void ExpandAllOf(Schema schema)
             }
         }
 
+        void CheckCircularAllOf(Schema schema, HashSet<Schema> visited, Stack<string> referenceChain)
+        {
+            visited = visited ?? new HashSet<Schema>();
+            referenceChain = referenceChain ?? new Stack<string>();
+            if (!visited.Add(schema)) // was already present in the set
+            {
+                var setDescription = "(" + String.Join(", ", referenceChain) + ")";
+                throw new InvalidOperationException(
+                    string.Format(CultureInfo.InvariantCulture,
+                    Properties.Resources.CircularBaseSchemaSet, setDescription));
+            }
+
+            if (schema.AllOf != null)
+            {
+                foreach (var reference in schema.AllOf.Select(s => s.Reference).Where(r => r != null))
+                {
+                    referenceChain.Push(reference);
+
+                    var deref = Dereference(reference);
+                    CheckCircularAllOf(deref, visited, referenceChain);
+
+                    Debug.Assert(reference == referenceChain.Peek());
+                    referenceChain.Pop();
+                }
+            }
+            visited.Remove(schema);
+        }
+
         /// <summary>
         /// Determine equivalence between the types described by two schemas. 
         /// Limit the comparison to exclude comparison of complexe inline schemas.