@@ -1118,24 +1118,13 @@ class Parser {
1118
1118
// / an error parsing.
1119
1119
bool parseVersionTuple (llvm::VersionTuple &Version, SourceRange &Range,
1120
1120
const Diagnostic &D);
1121
-
1122
1121
bool parseTypeAttributeList (ParamDecl::Specifier &Specifier,
1123
1122
SourceLoc &SpecifierLoc,
1124
- TypeAttributes &Attributes) {
1125
- if (Tok.isAny (tok::at_sign, tok::kw_inout) ||
1126
- (Tok.is (tok::identifier) &&
1127
- (Tok.getRawText ().equals (" __shared" ) ||
1128
- Tok.getRawText ().equals (" __owned" ))))
1129
- return parseTypeAttributeListPresent (Specifier, SpecifierLoc, Attributes);
1130
- return false ;
1131
- }
1132
- bool parseTypeAttributeListPresent (ParamDecl::Specifier &Specifier,
1133
- SourceLoc &SpecifierLoc,
1134
- TypeAttributes &Attributes);
1135
- bool parseTypeAttribute (TypeAttributes &Attributes, SourceLoc AtLoc,
1136
- bool justChecking = false );
1137
-
1138
-
1123
+ TypeAttributes &Attributes);
1124
+ ParserStatus parseTypeAttributeListSyntax (Optional<ParsedTokenSyntax> &specifier,
1125
+ Optional<ParsedAttributeListSyntax> &attrs);
1126
+ ParsedSyntaxResult<ParsedAttributeSyntax> parseTypeAttributeSyntax ();
1127
+
1139
1128
ParserResult<ImportDecl> parseDeclImport (ParseDeclOptions Flags,
1140
1129
DeclAttributes &Attributes);
1141
1130
ParserStatus parseInheritance (MutableArrayRef<TypeLoc> &Inherited,
@@ -1226,34 +1215,33 @@ class Parser {
1226
1215
// ===--------------------------------------------------------------------===//
1227
1216
// Type Parsing
1228
1217
1229
- using TypeASTResult = ParserResult<TypeRepr>;
1230
- using TypeResult = ParsedSyntaxResult<ParsedTypeSyntax>;
1218
+ ParserResult<TypeRepr> parseType ();
1219
+ ParserResult<TypeRepr> parseType (Diag<> MessageID,
1220
+ bool HandleCodeCompletion = true ,
1221
+ bool IsSILFuncDecl = false );
1222
+ ParserStatus parseGenericArguments (llvm::SmallVectorImpl<TypeRepr *> &ArgsAST,
1223
+ SourceLoc &LAngleLoc,
1224
+ SourceLoc &RAngleLoc);
1225
+ TypeRepr *applyAttributeToType (TypeRepr *Ty, const TypeAttributes &Attr,
1226
+ ParamDecl::Specifier Specifier,
1227
+ SourceLoc SpecifierLoc);
1228
+ ParserResult<TypeRepr> parseAnyTypeAST ();
1231
1229
1232
1230
ParsedSyntaxResult<ParsedLayoutConstraintSyntax>
1233
1231
parseLayoutConstraintSyntax ();
1234
1232
1235
- TypeResult parseTypeSyntax ();
1236
- TypeResult parseTypeSyntax (Diag<> MessageID, bool HandleCodeCompletion = true ,
1237
- bool IsSILFuncDecl = false );
1238
-
1239
- TypeASTResult parseType ();
1240
- TypeASTResult parseType (Diag<> MessageID, bool HandleCodeCompletion = true ,
1241
- bool IsSILFuncDecl = false );
1242
- ParserStatus
1243
- parseGenericArgumentsAST (llvm::SmallVectorImpl<TypeRepr *> &ArgsAST,
1244
- SourceLoc &LAngleLoc, SourceLoc &RAngleLoc);
1245
- TypeASTResult parseSILBoxType (GenericParamList *generics,
1246
- const TypeAttributes &attrs,
1247
- Optional<Scope> &GenericsScope);
1248
- TypeASTResult parseTypeSimpleOrCompositionAST (Diag<> MessageID,
1249
- bool HandleCodeCompletion);
1250
- TypeASTResult parseAnyTypeAST ();
1233
+ ParsedSyntaxResult<ParsedTypeSyntax> parseTypeSyntax ();
1234
+ ParsedSyntaxResult<ParsedTypeSyntax>
1235
+ parseTypeSyntax (Diag<> MessageID, bool HandleCodeCompletion = true ,
1236
+ bool IsSILFuncDecl = false );
1251
1237
1252
1238
ParsedSyntaxResult<ParsedGenericArgumentClauseSyntax>
1253
1239
parseGenericArgumentClauseSyntax ();
1254
1240
1255
- TypeResult parseTypeSimple (Diag<> MessageID, bool HandleCodeCompletion);
1256
- TypeResult parseTypeSimpleOrComposition (Diag<> MessageID, bool HandleCodeCompletion);
1241
+ ParsedSyntaxResult<ParsedTypeSyntax>
1242
+ parseTypeSimple (Diag<> MessageID, bool HandleCodeCompletion);
1243
+ ParsedSyntaxResult<ParsedTypeSyntax>
1244
+ parseTypeSimpleOrComposition (Diag<> MessageID, bool HandleCodeCompletion);
1257
1245
// SWIFT_ENABLE_TENSORFLOW: Added `isParsingQualifiedDeclName` flag.
1258
1246
// / Parses a type identifier (e.g. 'Foo' or 'Foo.Bar.Baz').
1259
1247
// /
@@ -1265,16 +1253,20 @@ class Parser {
1265
1253
// / positioned at '.f'.
1266
1254
// / - If there is no type qualification (e.g. when parsing just 'f'), returns
1267
1255
// / an empty parser error.
1268
- TypeResult parseTypeIdentifier (bool isParsingQualifiedDeclName = false );
1269
- TypeResult parseAnyType ();
1270
- TypeResult parseTypeTupleBody ();
1271
- TypeResult parseTypeCollection ();
1272
- TypeResult parseMetatypeType (ParsedTypeSyntax Base);
1273
- TypeResult parseOptionalType (ParsedTypeSyntax Base);
1274
- TypeResult parseImplicitlyUnwrappedOptionalType (ParsedTypeSyntax Base);
1275
-
1276
- TypeResult parseTypeArray (ParsedTypeSyntax Base, SourceLoc BaseLoc);
1277
- TypeResult parseOldStyleProtocolComposition ();
1256
+ ParsedSyntaxResult<ParsedTypeSyntax> parseTypeIdentifier (bool isParsingQualifiedDeclName = false );
1257
+ ParsedSyntaxResult<ParsedTypeSyntax> parseAnyType ();
1258
+ ParsedSyntaxResult<ParsedTypeSyntax> parseTypeTupleBody ();
1259
+ ParsedSyntaxResult<ParsedTypeSyntax> parseTypeCollection ();
1260
+ ParsedSyntaxResult<ParsedTypeSyntax> parseMetatypeType (ParsedTypeSyntax Base);
1261
+ ParsedSyntaxResult<ParsedTypeSyntax> parseOptionalType (ParsedTypeSyntax Base);
1262
+ ParsedSyntaxResult<ParsedTypeSyntax>
1263
+ parseImplicitlyUnwrappedOptionalType (ParsedTypeSyntax Base);
1264
+ ParsedSyntaxResult<ParsedTypeSyntax> parseSILBoxTypeSyntax (
1265
+ Optional<ParsedGenericParameterClauseListSyntax> genericParams);
1266
+
1267
+ ParsedSyntaxResult<ParsedTypeSyntax> parseTypeArray (ParsedTypeSyntax Base,
1268
+ SourceLoc BaseLoc);
1269
+ ParsedSyntaxResult<ParsedTypeSyntax> parseOldStyleProtocolComposition ();
1278
1270
1279
1271
bool isOptionalToken (const Token &T) const ;
1280
1272
ParsedTokenSyntax consumeOptionalTokenSyntax ();
@@ -1284,9 +1276,10 @@ class Parser {
1284
1276
ParsedTokenSyntax consumeImplicitlyUnwrappedOptionalTokenSyntax ();
1285
1277
SourceLoc consumeImplicitlyUnwrappedOptionalToken ();
1286
1278
1287
- TypeRepr *applyAttributeToType (TypeRepr *Ty, const TypeAttributes &Attr,
1288
- ParamDecl::Specifier Specifier,
1289
- SourceLoc SpecifierLoc);
1279
+ ParsedSyntaxResult<ParsedTypeSyntax>
1280
+ applyAttributeToTypeSyntax (ParsedSyntaxResult<ParsedTypeSyntax> &&ty,
1281
+ Optional<ParsedTokenSyntax> specifier,
1282
+ Optional<ParsedAttributeListSyntax> attrs);
1290
1283
1291
1284
// ===--------------------------------------------------------------------===//
1292
1285
// Pattern Parsing
0 commit comments