Parts. Support for parsing and (not) reporting errors.

Change-Id: I4f352b7cc0c782eba96cd63e5b4a605657fd5c5c
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/375541
Commit-Queue: Konstantin Shcheglov <[email protected]>
Reviewed-by: Brian Wilkerson <[email protected]>
Reviewed-by: Johnni Winther <[email protected]>

Author: scheglov

pkg/_fe_analyzer_shared/lib/src/parser/directive_context.dart

@@ -7,8 +7,15 @@ import '../scanner/token.dart';
 import 'parser_impl.dart';
 
 class DirectiveContext {
+  /// Whether the `enhanced-parts` feature is enabled.
+  final bool enableFeatureEnhancedParts;
+
   DirectiveState state = DirectiveState.Unknown;
 
+  DirectiveContext({
+    required this.enableFeatureEnhancedParts,
+  });
+
   void checkScriptTag(Parser parser, Token token) {
     if (state == DirectiveState.Unknown) {
       state = DirectiveState.Script;
@@ -26,32 +33,42 @@ class DirectiveContext {
   }
 
   void checkExport(Parser parser, Token token) {
-    if (state.index <= DirectiveState.ImportAndExport.index) {
-      state = DirectiveState.ImportAndExport;
-      return;
-    }
-    // Recovery
-    if (state == DirectiveState.Part) {
-      parser.reportRecoverableError(token, messageExportAfterPart);
-    } else if (state == DirectiveState.PartOf) {
-      parser.reportRecoverableError(token, messageNonPartOfDirectiveInPart);
-    } else {
-      parser.reportRecoverableError(token, messageDirectiveAfterDeclaration);
+    switch (state) {
+      case DirectiveState.Unknown:
+      case DirectiveState.Script:
+      case DirectiveState.Library:
+      case DirectiveState.ImportAndExport:
+        state = DirectiveState.ImportAndExport;
+      case DirectiveState.Part:
+        parser.reportRecoverableError(token, messageExportAfterPart);
+      case DirectiveState.PartOf:
+        if (enableFeatureEnhancedParts) {
+          state = DirectiveState.ImportAndExport;
+        } else {
+          parser.reportRecoverableError(token, messageNonPartOfDirectiveInPart);
+        }
+      case DirectiveState.Declarations:
+        parser.reportRecoverableError(token, messageDirectiveAfterDeclaration);
     }
   }
 
   void checkImport(Parser parser, Token token) {
-    if (state.index <= DirectiveState.ImportAndExport.index) {
-      state = DirectiveState.ImportAndExport;
-      return;
-    }
-    // Recovery
-    if (state == DirectiveState.Part) {
-      parser.reportRecoverableError(token, messageImportAfterPart);
-    } else if (state == DirectiveState.PartOf) {
-      parser.reportRecoverableError(token, messageNonPartOfDirectiveInPart);
-    } else {
-      parser.reportRecoverableError(token, messageDirectiveAfterDeclaration);
+    switch (state) {
+      case DirectiveState.Unknown:
+      case DirectiveState.Script:
+      case DirectiveState.Library:
+      case DirectiveState.ImportAndExport:
+        state = DirectiveState.ImportAndExport;
+      case DirectiveState.Part:
+        parser.reportRecoverableError(token, messageImportAfterPart);
+      case DirectiveState.PartOf:
+        if (enableFeatureEnhancedParts) {
+          state = DirectiveState.ImportAndExport;
+        } else {
+          parser.reportRecoverableError(token, messageNonPartOfDirectiveInPart);
+        }
+      case DirectiveState.Declarations:
+        parser.reportRecoverableError(token, messageDirectiveAfterDeclaration);
     }
   }
 
@@ -71,15 +88,21 @@ class DirectiveContext {
   }
 
   void checkPart(Parser parser, Token token) {
-    if (state.index <= DirectiveState.Part.index) {
-      state = DirectiveState.Part;
-      return;
-    }
-    // Recovery
-    if (state == DirectiveState.PartOf) {
-      parser.reportRecoverableError(token, messageNonPartOfDirectiveInPart);
-    } else {
-      parser.reportRecoverableError(token, messageDirectiveAfterDeclaration);
+    switch (state) {
+      case DirectiveState.Unknown:
+      case DirectiveState.Script:
+      case DirectiveState.Library:
+      case DirectiveState.ImportAndExport:
+      case DirectiveState.Part:
+        state = DirectiveState.Part;
+      case DirectiveState.PartOf:
+        if (enableFeatureEnhancedParts) {
+          state = DirectiveState.ImportAndExport;
+        } else {
+          parser.reportRecoverableError(token, messageNonPartOfDirectiveInPart);
+        }
+      case DirectiveState.Declarations:
+        parser.reportRecoverableError(token, messageDirectiveAfterDeclaration);
     }
   }
 

pkg/_fe_analyzer_shared/lib/src/parser/parser_impl.dart

@@ -338,10 +338,14 @@ class Parser {
   /// [parsePrimaryPattern] and [parsePattern].
   bool isLastPatternAllowedInsideUnaryPattern = false;
 
+  /// Whether the `enhanced-parts` feature is enabled.
+  final bool enableFeatureEnhancedParts;
+
   Parser(
     this.listener, {
     this.useImplicitCreationExpression = true,
     this.allowPatterns = false,
+    this.enableFeatureEnhancedParts = false,
   }) : assert(listener != null); // ignore:unnecessary_null_comparison
 
   /// Executes [callback]; however if `this` is the `TestParser` (from
@@ -401,7 +405,9 @@ class Parser {
 
     listener.beginCompilationUnit(token);
     int count = 0;
-    DirectiveContext directiveState = new DirectiveContext();
+    DirectiveContext directiveState = new DirectiveContext(
+      enableFeatureEnhancedParts: enableFeatureEnhancedParts,
+    );
     token = syntheticPreviousToken(token);
     if (identical(token.next!.type, TokenType.SCRIPT_TAG)) {
       directiveState.checkScriptTag(this, token.next!);
@@ -448,7 +454,9 @@ class Parser {
   Token parseDirectives(Token token) {
     listener.beginCompilationUnit(token);
     int count = 0;
-    DirectiveContext directiveState = new DirectiveContext();
+    DirectiveContext directiveState = new DirectiveContext(
+      enableFeatureEnhancedParts: enableFeatureEnhancedParts,
+    );
     token = syntheticPreviousToken(token);
     while (!token.next!.isEof) {
       final Token start = token.next!;
@@ -1227,13 +1235,14 @@ class Parser {
 
   /// ```
   /// partDirective:
-  ///   'part' uri ';'
+  ///   'part' uri ('if' '(' test ')' uri)* ';'
   /// ;
   /// ```
   Token parsePart(Token partKeyword) {
     assert(optional('part', partKeyword));
     listener.beginPart(partKeyword);
     Token token = ensureLiteralString(partKeyword);
+    token = parseConditionalUriStar(token);
     token = ensureSemicolon(token);
     listener.endPart(partKeyword, token);
     return token;

pkg/analyzer/lib/src/dart/ast/ast.dart

@@ -13256,6 +13256,9 @@ final class ParenthesizedPatternImpl extends DartPatternImpl
 ///    partDirective ::=
 ///        [Annotation] 'part' [StringLiteral] ';'
 abstract final class PartDirective implements UriBasedDirective {
+  /// The configurations that control which file is actually included.
+  NodeList<Configuration> get configurations;
+
   @override
   PartElement? get element;
 
@@ -13271,6 +13274,9 @@ final class PartDirectiveImpl extends UriBasedDirectiveImpl
   @override
   final Token partKeyword;
 
+  @override
+  final NodeListImpl<ConfigurationImpl> configurations = NodeListImpl._();
+
   @override
   final Token semicolon;
 
@@ -13283,8 +13289,11 @@ final class PartDirectiveImpl extends UriBasedDirectiveImpl
     required super.metadata,
     required this.partKeyword,
     required super.uri,
+    required List<ConfigurationImpl>? configurations,
     required this.semicolon,
-  });
+  }) {
+    this.configurations._initialize(this, configurations);
+  }
 
   @override
   PartElementImpl? get element {
@@ -13301,6 +13310,7 @@ final class PartDirectiveImpl extends UriBasedDirectiveImpl
   ChildEntities get _childEntities => super._childEntities
     ..addToken('partKeyword', partKeyword)
     ..addNode('uri', uri)
+    ..addNodeList('configurations', configurations)
     ..addToken('semicolon', semicolon);
 
   @override

pkg/analyzer/lib/src/fasta/ast_builder.dart

@@ -2779,6 +2779,18 @@ class AstBuilder extends StackListener {
     assert(optional(';', semicolon));
     debugEvent("Part");
 
+    var configurations = pop() as List<ConfigurationImpl>?;
+    if (!enableEnhancedParts) {
+      var configuration = configurations?.firstOrNull;
+      if (configuration != null) {
+        _reportFeatureNotEnabled(
+          feature: Feature.enhanced_parts,
+          startToken: configuration.ifKeyword,
+        );
+        configurations = [];
+      }
+    }
+
     var uri = pop() as StringLiteralImpl;
     var metadata = pop() as List<AnnotationImpl>?;
     var comment = _findComment(metadata, partKeyword);
@@ -2788,6 +2800,7 @@ class AstBuilder extends StackListener {
         metadata: metadata,
         partKeyword: partKeyword,
         uri: uri,
+        configurations: configurations,
         semicolon: semicolon,
       ),
     );

pkg/analyzer/lib/src/generated/parser.dart

@@ -41,6 +41,7 @@ class Parser {
     fastaParser = fasta.Parser(
       astBuilder,
       allowPatterns: featureSet.isEnabled(Feature.patterns),
+      enableFeatureEnhancedParts: featureSet.isEnabled(Feature.enhanced_parts),
     );
     astBuilder.parser = fastaParser;
     astBuilder.allowNativeClause = allowNativeClause;

pkg/analyzer/lib/src/test_utilities/find_node.dart

@@ -140,6 +140,8 @@ class FindNode {
 
   ParenthesizedExpression get singleParenthesizedExpression => _single();
 
+  PartDirective get singlePartDirective => _single();
+
   PatternAssignment get singlePatternAssignment => _single();
 
   PatternVariableDeclaration get singlePatternVariableDeclaration => _single();

pkg/analyzer/test/generated/error_parser_test.dart

@@ -926,13 +926,6 @@ class Foo {
     ]);
   }
 
-  void test_exportDirectiveAfterPartDirective() {
-    parseCompilationUnit("part 'a.dart'; export 'b.dart';", errors: [
-      expectedError(
-          ParserErrorCode.EXPORT_DIRECTIVE_AFTER_PART_DIRECTIVE, 15, 6)
-    ]);
-  }
-
   void test_externalAfterConst() {
     createParser('const external C();');
     ClassMember member = parser.parseClassMember('C');
@@ -1394,13 +1387,6 @@ class Wrong<T> {
         errors: [expectedError(ParserErrorCode.IMPLEMENTS_BEFORE_WITH, 31, 4)]);
   }
 
-  void test_importDirectiveAfterPartDirective() {
-    parseCompilationUnit("part 'a.dart'; import 'b.dart';", errors: [
-      expectedError(
-          ParserErrorCode.IMPORT_DIRECTIVE_AFTER_PART_DIRECTIVE, 15, 6)
-    ]);
-  }
-
   void test_initializedVariableInForEach() {
     var statement = parseStatement('for (int a = 0 in foo) {}');
     expectNotNullIfNoErrors(statement);
@@ -2377,21 +2363,6 @@ class Wrong<T> {
     expect(unit, isNotNull);
   }
 
-  void test_nonPartOfDirectiveInPart_after() {
-    parseCompilationUnit("part of l; part 'f.dart';", errors: [
-      expectedError(ParserErrorCode.NON_PART_OF_DIRECTIVE_IN_PART, 11, 4)
-    ]);
-  }
-
-  void test_nonPartOfDirectiveInPart_before() {
-    // TODO(brianwilkerson): Remove codes when highlighting is fixed.
-    parseCompilationUnit("part 'f.dart'; part of m;", codes: [
-      ParserErrorCode.NON_PART_OF_DIRECTIVE_IN_PART
-    ], errors: [
-      expectedError(ParserErrorCode.NON_PART_OF_DIRECTIVE_IN_PART, 0, 4)
-    ]);
-  }
-
   void test_nonUserDefinableOperator() {
     createParser('operator +=(int x) => x + 1;');
     ClassMember member = parser.parseClassMember('C');

pkg/analyzer/test/generated/parser_test_base.dart

@@ -396,6 +396,7 @@ class FastaParserTestCase
     fasta.Parser parser = fasta.Parser(
       astBuilder,
       allowPatterns: featureSet!.isEnabled(Feature.patterns),
+      enableFeatureEnhancedParts: featureSet!.isEnabled(Feature.enhanced_parts),
     );
     astBuilder.parser = parser;
     astBuilder.allowNativeClause = allowNativeClause;