[SyntaxParse] Finish type parsing

include/swift/Parse/ASTGen.h

@@ -37,9 +37,8 @@ class ASTGen {
 
   // FIXME: remove when Syntax can represent all types and ASTGen can handle
   // them
-  /// Types that cannot be represented by Syntax or generated by ASTGen.
-  llvm::DenseMap<SourceLoc, TypeRepr *> Types;
-
+  /// Decl attributes that cannot be represented by Syntax or generated by
+  /// ASTGen.
   llvm::DenseMap<SourceLoc, DeclAttributes> ParsedDeclAttrs;
 
 public:
@@ -103,7 +102,8 @@ class ASTGen {
   //===--------------------------------------------------------------------===//
   // Types.
 
-  TypeRepr *generate(const syntax::TypeSyntax &Type, const SourceLoc Loc);
+  TypeRepr *generate(const syntax::TypeSyntax &Type, const SourceLoc Loc,
+                     bool IsSILFuncDecl = false);
   TypeRepr *generate(const syntax::SomeTypeSyntax &Type, const SourceLoc Loc);
   TypeRepr *generate(const syntax::CompositionTypeSyntax &Type,
                      const SourceLoc Loc);
@@ -127,11 +127,19 @@ class ASTGen {
                      const SourceLoc Loc);
   TypeRepr *generate(const syntax::ClassRestrictionTypeSyntax &Type,
                      const SourceLoc Loc);
+  TypeRepr *generate(const syntax::SILBoxTypeSyntax &Type, const SourceLoc Loc,
+                     bool IsSILFuncDecl);
+  TypeRepr *generate(const syntax::SILFunctionTypeSyntax &Type,
+                     const SourceLoc Loc, bool IsSILFuncDecl);
   TypeRepr *generate(const syntax::CodeCompletionTypeSyntax &Type,
                      const SourceLoc Loc);
   TypeRepr *generate(const syntax::UnknownTypeSyntax &Type,
                      const SourceLoc Loc);
 
+  TypeAttributes
+  generateTypeAttributes(const syntax::AttributeListSyntax &syntax,
+                         const SourceLoc Loc);
+
 private:
   TupleTypeRepr *
   generateTuple(const syntax::TokenSyntax &LParen,
@@ -196,10 +204,6 @@ class ASTGen {
   TypeRepr *lookupType(syntax::TypeSyntax Type);
 
 public:
-  void addType(TypeRepr *Type, const SourceLoc Loc);
-  bool hasType(const SourceLoc Loc) const;
-  TypeRepr *getType(const SourceLoc Loc) const;
-
   void addDeclAttributes(DeclAttributes attrs, const SourceLoc Loc);
   bool hasDeclAttributes(SourceLoc Loc) const;
   DeclAttributes getDeclAttributes(const SourceLoc Loc) const;

include/swift/Parse/ParsedRawSyntaxNode.h

@@ -119,8 +119,20 @@ class ParsedRawSyntaxNode {
     assert(getTokenKind() == tokKind && "Token kind with too large value!");
   }
 
+#ifndef NDEBUG
+  bool ensureDataIsNotRecorded() {
+    if (DK != DataKind::Recorded)
+      return true;
+    llvm::dbgs() << "Leaking node: ";
+    dump(llvm::dbgs());
+    llvm::dbgs() << "\n";
+    return false;
+  }
+#endif
+
   ParsedRawSyntaxNode &operator=(ParsedRawSyntaxNode &&other) {
-    assert(DK != DataKind::Recorded);
+    assert(ensureDataIsNotRecorded() &&
+           "recorded data is being destroyed by assignment");
     switch (other.DK) {
     case DataKind::Null:
       break;
@@ -145,7 +157,7 @@ class ParsedRawSyntaxNode {
     *this = std::move(other);
   }
   ~ParsedRawSyntaxNode() {
-    assert(DK != DataKind::Recorded);
+    assert(ensureDataIsNotRecorded() && "recorded data is being destructed");
   }
 
   syntax::SyntaxKind getKind() const { return syntax::SyntaxKind(SynKind); }

include/swift/Parse/Parser.h

@@ -1082,24 +1082,13 @@ class Parser {
   /// an error parsing.
   bool parseVersionTuple(llvm::VersionTuple &Version, SourceRange &Range,
                          const Diagnostic &D);
-
   bool parseTypeAttributeList(ParamDecl::Specifier &Specifier,
                               SourceLoc &SpecifierLoc,
-                              TypeAttributes &Attributes) {
-    if (Tok.isAny(tok::at_sign, tok::kw_inout) ||
-        (Tok.is(tok::identifier) &&
-         (Tok.getRawText().equals("__shared") ||
-          Tok.getRawText().equals("__owned"))))
-      return parseTypeAttributeListPresent(Specifier, SpecifierLoc, Attributes);
-    return false;
-  }
-  bool parseTypeAttributeListPresent(ParamDecl::Specifier &Specifier,
-                                     SourceLoc &SpecifierLoc,
-                                     TypeAttributes &Attributes);
-  bool parseTypeAttribute(TypeAttributes &Attributes, SourceLoc AtLoc,
-                          bool justChecking = false);
-
-
+                              TypeAttributes &Attributes);
+  ParserStatus parseTypeAttributeListSyntax(Optional<ParsedTokenSyntax> &specifier,
+                                            Optional<ParsedAttributeListSyntax> &attrs);
+  ParsedSyntaxResult<ParsedAttributeSyntax> parseTypeAttributeSyntax();
+
   ParserResult<ImportDecl> parseDeclImport(ParseDeclOptions Flags,
                                            DeclAttributes &Attributes);
   ParserStatus parseInheritance(MutableArrayRef<TypeLoc> &Inherited,
@@ -1190,44 +1179,47 @@ class Parser {
   //===--------------------------------------------------------------------===//
   // Type Parsing
 
-  using TypeASTResult = ParserResult<TypeRepr>;
-  using TypeResult = ParsedSyntaxResult<ParsedTypeSyntax>;
+  ParserResult<TypeRepr> parseType();
+  ParserResult<TypeRepr> parseType(Diag<> MessageID,
+                                   bool HandleCodeCompletion = true,
+                                   bool IsSILFuncDecl = false);
+  ParserStatus parseGenericArguments(llvm::SmallVectorImpl<TypeRepr *> &ArgsAST,
+                                     SourceLoc &LAngleLoc,
+                                     SourceLoc &RAngleLoc);
+  TypeRepr *applyAttributeToType(TypeRepr *Ty, const TypeAttributes &Attr,
+                                 ParamDecl::Specifier Specifier,
+                                 SourceLoc SpecifierLoc);
+  ParserResult<TypeRepr> parseAnyTypeAST();
 
   ParsedSyntaxResult<ParsedLayoutConstraintSyntax>
   parseLayoutConstraintSyntax();
 
-  TypeResult parseTypeSyntax();
-  TypeResult parseTypeSyntax(Diag<> MessageID, bool HandleCodeCompletion = true,
-                             bool IsSILFuncDecl = false);
-
-  TypeASTResult parseType();
-  TypeASTResult parseType(Diag<> MessageID, bool HandleCodeCompletion = true,
-                          bool IsSILFuncDecl = false);
-  ParserStatus
-  parseGenericArgumentsAST(llvm::SmallVectorImpl<TypeRepr *> &ArgsAST,
-                           SourceLoc &LAngleLoc, SourceLoc &RAngleLoc);
-  TypeASTResult parseSILBoxType(GenericParamList *generics,
-                                const TypeAttributes &attrs,
-                                Optional<Scope> &GenericsScope);
-  TypeASTResult parseTypeSimpleOrCompositionAST(Diag<> MessageID,
-                                                bool HandleCodeCompletion);
-  TypeASTResult parseAnyTypeAST();
+  ParsedSyntaxResult<ParsedTypeSyntax> parseTypeSyntax();
+  ParsedSyntaxResult<ParsedTypeSyntax>
+  parseTypeSyntax(Diag<> MessageID, bool HandleCodeCompletion = true,
+                  bool IsSILFuncDecl = false);
 
   ParsedSyntaxResult<ParsedGenericArgumentClauseSyntax>
   parseGenericArgumentClauseSyntax();
 
-  TypeResult parseTypeSimple(Diag<> MessageID, bool HandleCodeCompletion);
-  TypeResult parseTypeSimpleOrComposition(Diag<> MessageID, bool HandleCodeCompletion);
-  TypeResult parseTypeIdentifier();
-  TypeResult parseAnyType();
-  TypeResult parseTypeTupleBody();
-  TypeResult parseTypeCollection();
-  TypeResult parseMetatypeType(ParsedTypeSyntax Base);
-  TypeResult parseOptionalType(ParsedTypeSyntax Base);
-  TypeResult parseImplicitlyUnwrappedOptionalType(ParsedTypeSyntax Base);
-
-  TypeResult parseTypeArray(ParsedTypeSyntax Base, SourceLoc BaseLoc);
-  TypeResult parseOldStyleProtocolComposition();
+  ParsedSyntaxResult<ParsedTypeSyntax>
+  parseTypeSimple(Diag<> MessageID, bool HandleCodeCompletion);
+  ParsedSyntaxResult<ParsedTypeSyntax>
+  parseTypeSimpleOrComposition(Diag<> MessageID, bool HandleCodeCompletion);
+  ParsedSyntaxResult<ParsedTypeSyntax> parseTypeIdentifier();
+  ParsedSyntaxResult<ParsedTypeSyntax> parseAnyType();
+  ParsedSyntaxResult<ParsedTypeSyntax> parseTypeTupleBody();
+  ParsedSyntaxResult<ParsedTypeSyntax> parseTypeCollection();
+  ParsedSyntaxResult<ParsedTypeSyntax> parseMetatypeType(ParsedTypeSyntax Base);
+  ParsedSyntaxResult<ParsedTypeSyntax> parseOptionalType(ParsedTypeSyntax Base);
+  ParsedSyntaxResult<ParsedTypeSyntax>
+  parseImplicitlyUnwrappedOptionalType(ParsedTypeSyntax Base);
+  ParsedSyntaxResult<ParsedTypeSyntax> parseSILBoxTypeSyntax(
+      Optional<ParsedGenericParameterClauseListSyntax> genericParams);
+
+  ParsedSyntaxResult<ParsedTypeSyntax> parseTypeArray(ParsedTypeSyntax Base,
+                                                      SourceLoc BaseLoc);
+  ParsedSyntaxResult<ParsedTypeSyntax> parseOldStyleProtocolComposition();
 
   bool isOptionalToken(const Token &T) const;
   ParsedTokenSyntax consumeOptionalTokenSyntax();
@@ -1237,9 +1229,10 @@ class Parser {
   ParsedTokenSyntax consumeImplicitlyUnwrappedOptionalTokenSyntax();
   SourceLoc consumeImplicitlyUnwrappedOptionalToken();
 
-  TypeRepr *applyAttributeToType(TypeRepr *Ty, const TypeAttributes &Attr,
-                                 ParamDecl::Specifier Specifier,
-                                 SourceLoc SpecifierLoc);
+  ParsedSyntaxResult<ParsedTypeSyntax>
+  applyAttributeToTypeSyntax(ParsedSyntaxResult<ParsedTypeSyntax> &&ty,
+                             Optional<ParsedTokenSyntax> specifier,
+                             Optional<ParsedAttributeListSyntax> attrs);
 
   //===--------------------------------------------------------------------===//
   // Pattern Parsing