[IDE] Fix SyntaxModel crash due to out-of-order walking of EnumElementDecls

lib/IDE/SyntaxModel.cpp

@@ -248,7 +248,7 @@ class ModelASTWalker : public ASTWalker {
 
   Optional<SyntaxNode> parseFieldNode(StringRef Text, StringRef OrigText,
                                       SourceLoc OrigLoc);
-  llvm::DenseSet<ASTNode> VisitedNodesInsideIfConfig;
+  llvm::DenseSet<ASTNode> NodesVisitedBefore;
   /// When non-zero, we should avoid passing tokens as syntax nodes since a parent of several tokens
   /// is considered as one, e.g. object literal expression.
   uint8_t AvoidPassingSyntaxToken = 0;
@@ -310,8 +310,8 @@ class ModelASTWalker : public ASTWalker {
   bool searchForURL(CharSourceRange Range);
   bool findFieldsInDocCommentLine(SyntaxNode Node);
   bool findFieldsInDocCommentBlock(SyntaxNode Node);
-  bool isVisitedBeforeInIfConfig(ASTNode Node) {
-    return VisitedNodesInsideIfConfig.count(Node) > 0;
+  bool isVisitedBefore(ASTNode Node) {
+    return NodesVisitedBefore.count(Node) > 0;
   }
 };
 
@@ -417,7 +417,7 @@ void ModelASTWalker::visitSourceFile(SourceFile &SrcFile,
 }
 
 std::pair<bool, Expr *> ModelASTWalker::walkToExprPre(Expr *E) {
-  if (isVisitedBeforeInIfConfig(E))
+  if (isVisitedBefore(E))
     return {false, E};
 
   auto addCallArgExpr = [&](Expr *Elem, TupleExpr *ParentTupleExpr) {
@@ -568,7 +568,7 @@ Expr *ModelASTWalker::walkToExprPost(Expr *E) {
 }
 
 std::pair<bool, Stmt *> ModelASTWalker::walkToStmtPre(Stmt *S) {
-  if (isVisitedBeforeInIfConfig(S)) {
+  if (isVisitedBefore(S)) {
     return {false, S};
   }
   auto addExprElem = [&](SyntaxStructureElementKind K, const Expr *Elem,
@@ -710,7 +710,7 @@ Stmt *ModelASTWalker::walkToStmtPost(Stmt *S) {
 }
 
 bool ModelASTWalker::walkToDeclPre(Decl *D) {
-  if (isVisitedBeforeInIfConfig(D))
+  if (isVisitedBefore(D))
     return false;
   if (D->isImplicit())
     return false;
@@ -850,7 +850,7 @@ bool ModelASTWalker::walkToDeclPre(Decl *D) {
         } else {
           Element.get<Decl*>()->walk(*this);
         }
-        VisitedNodesInsideIfConfig.insert(Element);
+        NodesVisitedBefore.insert(Element);
       }
     }
 
@@ -888,13 +888,6 @@ bool ModelASTWalker::walkToDeclPre(Decl *D) {
           SourceRange NameRange = SourceRange(EnumElemD->getNameLoc(),
                                               ParamList->getSourceRange().End);
           SN.NameRange = charSourceRangeFromSourceRange(SM, NameRange);
-
-          for (auto Param : ParamList->getArray()) {
-            auto TL = Param->getTypeLoc();
-            CharSourceRange TR = charSourceRangeFromSourceRange(SM,
-                                                                TL.getSourceRange());
-            passNonTokenNode({SyntaxNodeKind::TypeId, TR});
-          }
         } else {
           SN.NameRange = CharSourceRange(EnumElemD->getNameLoc(),
                                          EnumElemD->getName().getLength());
@@ -906,7 +899,8 @@ bool ModelASTWalker::walkToDeclPre(Decl *D) {
                                  charSourceRangeFromSourceRange(SM, ElemRange));
         }
         pushStructureNode(SN, EnumElemD);
-        popStructureNode();
+        EnumElemD->walk(*this);
+        NodesVisitedBefore.insert(EnumElemD);
       }
     }
   } else if (auto *TypeAliasD = dyn_cast<TypeAliasDecl>(D)) {
@@ -1039,12 +1033,17 @@ bool ModelASTWalker::handleSpecialDeclAttribute(const DeclAttribute *D,
         if (!Arg->walk(*this))
           return false;
       }
-    } else {
+    } else if (!TokenNodes.empty()) {
       auto Next = TokenNodes.front();
-      TokenNodes = TokenNodes.drop_front();
-      assert(Next.Range.getStart() == D->getRangeWithAt().Start);
-      if (!passNode({SyntaxNodeKind::AttributeBuiltin, Next.Range}))
-        return false;
+      if (Next.Range.getStart() == D->getRangeWithAt().Start) {
+        TokenNodes = TokenNodes.drop_front();
+        if (!passNode({SyntaxNodeKind::AttributeBuiltin, Next.Range}))
+          return false;
+      } else {
+          assert(0 && "Attribute's TokenNodes already consumed?");
+      }
+    } else {
+        assert(0 && "No TokenNodes?");
     }
     if (!passTokenNodesUntil(D->getRange().End, PassNodesBehavior::IncludeNodeAtLocation))
       return false;
@@ -1177,7 +1176,7 @@ bool ModelASTWalker::passNonTokenNode(const SyntaxNode &Node) {
   // such as multiple PatternBindingDecl in code like: var a, b : Int. Which
   // would cause us to report the TypeRepr twice.
   if (!SM.isBeforeInBuffer(LastLoc, Node.Range.getStart()))
-    return false;
+    return true;
 
   if (!passTokenNodesUntil(Node.Range.getStart(), DisplaceNodeAtLocation))
     return false;

test/IDE/coloring.swift

@@ -18,6 +18,15 @@ struct S {
   var a, b : Int
 }
 
+enum EnumWhereCaseHasADefaultedFunctionTypeParam {
+// CHECK: <kw>enum</kw> EnumWhereCaseHasADefaultedFunctionTypeParam {
+  case foo(x: () -> () = {
+  // CHECK: <kw>case</kw> foo(x: () -> () = {
+    func inner(x: S) {}
+    // CHECK: <kw>func</kw> inner(x: <type>S</type>) {}
+  })
+}
+
 enum EnumWithDerivedEquatableConformance : Int {
 // CHECK-LABEL: <kw>enum</kw> EnumWithDerivedEquatableConformance : {{(<type>)}}Int{{(</type>)?}} {
   case CaseA

test/IDE/coloring_invalid.swift

@@ -0,0 +1,11 @@
+// RUN: %target-swift-ide-test -syntax-coloring -source-filename %s | %FileCheck %s
+
+public enum Result {
+// CHECK: <attr-builtin>public</attr-builtin> <kw>enum</kw> Result {
+  case success(a b = {
+// CHECK: <kw>case</kw> success(a b = {
+
+@available(*)
+// CHECK: <attr-builtin>@available</attr-builtin>(*)
+func materialize
+// CHECK: <kw>func</kw> materialize

test/IDE/structure.swift

@@ -293,3 +293,15 @@ myFunc(foo: 0,
        bar: baz == 0)
 // CHECK: <call><name>myFunc</name>(<arg><name>foo</name>: 0</arg>,
 // CHECK:        <arg><name>bar</name>: baz == 0</arg>)</call>
+
+
+enum FooEnum {
+// CHECK: <enum>enum <name>FooEnum</name> {
+  case blah(x: () -> () = {
+  // CHECK: <enum-case>case <enum-elem><name>blah(<param><name>x</name>: <type>() -> ()</type> = <closure><brace>{
+    @Tuples func foo(x: MyStruc) {}
+    // CHECK: @Tuples <ffunc>func <name>foo(<param><name>x</name>: <type>MyStruc</type></param>)</name> {}</ffunc>
+  })
+  // CHECK: }</brace></closure></param>)</name></enum-elem></enum-case>
+}
+// CHECK: }</enum>

test/SourceKit/DocumentStructure/structure.swift.empty.response

@@ -1269,18 +1269,20 @@
               key.offset: 2011,
               key.length: 13,
               key.nameoffset: 2011,
-              key.namelength: 13
+              key.namelength: 13,
+              key.substructure: [
+                {
+                  key.kind: source.lang.swift.decl.var.parameter,
+                  key.name: "arg",
+                  key.offset: 2015,
+                  key.length: 8,
+                  key.typename: "Int",
+                  key.nameoffset: 2015,
+                  key.namelength: 3
+                }
+              ]
             }
           ]
-        },
-        {
-          key.kind: source.lang.swift.decl.var.parameter,
-          key.name: "arg",
-          key.offset: 2015,
-          key.length: 8,
-          key.typename: "Int",
-          key.nameoffset: 2015,
-          key.namelength: 3
         }
       ]
     },

test/SourceKit/DocumentStructure/structure.swift.foobar.response

@@ -1269,18 +1269,20 @@
               key.offset: 2011,
               key.length: 13,
               key.nameoffset: 2011,
-              key.namelength: 13
+              key.namelength: 13,
+              key.substructure: [
+                {
+                  key.kind: source.lang.swift.decl.var.parameter,
+                  key.name: "arg",
+                  key.offset: 2015,
+                  key.length: 8,
+                  key.typename: "Int",
+                  key.nameoffset: 2015,
+                  key.namelength: 3
+                }
+              ]
             }
           ]
-        },
-        {
-          key.kind: source.lang.swift.decl.var.parameter,
-          key.name: "arg",
-          key.offset: 2015,
-          key.length: 8,
-          key.typename: "Int",
-          key.nameoffset: 2015,
-          key.namelength: 3
         }
       ]
     },

test/SourceKit/DocumentStructure/structure.swift.response

@@ -1269,18 +1269,20 @@
               key.offset: 2011,
               key.length: 13,
               key.nameoffset: 2011,
-              key.namelength: 13
+              key.namelength: 13,
+              key.substructure: [
+                {
+                  key.kind: source.lang.swift.decl.var.parameter,
+                  key.name: "arg",
+                  key.offset: 2015,
+                  key.length: 8,
+                  key.typename: "Int",
+                  key.nameoffset: 2015,
+                  key.namelength: 3
+                }
+              ]
             }
           ]
-        },
-        {
-          key.kind: source.lang.swift.decl.var.parameter,
-          key.name: "arg",
-          key.offset: 2015,
-          key.length: 8,
-          key.typename: "Int",
-          key.nameoffset: 2015,
-          key.namelength: 3
         }
       ]
     },

test/SourceKit/InterfaceGen/gen_swift_source.swift.response

@@ -595,6 +595,26 @@ internal enum Colors {
             key.attribute: source.decl.attribute.internal
           }
         ]
+      },
+      {
+        key.kind: source.lang.swift.decl.var.instance,
+        key.accessibility: source.lang.swift.accessibility.internal,
+        key.setter_accessibility: source.lang.swift.accessibility.internal,
+        key.name: "p2",
+        key.offset: 559,
+        key.length: 24,
+        key.typename: "(Int, Int)",
+        key.nameoffset: 568,
+        key.namelength: 2,
+        key.docoffset: 527,
+        key.doclength: 19,
+        key.attributes: [
+          {
+            key.offset: 550,
+            key.length: 8,
+            key.attribute: source.decl.attribute.internal
+          }
+        ]
       }
     ]
   },

tools/SourceKit/lib/SwiftLang/SwiftLangSupport.cpp

@@ -467,7 +467,9 @@ UIdent SwiftLangSupport::getUIDForSyntaxNodeKind(SyntaxNodeKind SC) {
     return KindObjectLiteral;
   }
 
-  llvm_unreachable("Unhandled SyntaxNodeKind in switch.");
+  // Default to a known kind to prevent crashing in non-asserts builds
+  assert(0 && "Unhandled SyntaxNodeKind in switch.");
+  return KindIdentifier;
 }
 
 UIdent SwiftLangSupport::getUIDForSyntaxStructureKind(