[fasta] Preserve information about const constructors in outline.

- for classes with const constructors parse field initializers;
- for const constructions parse initializer lists and default parameter
values;

Fixes issue #37357
Fixes issue #36635

Change-Id: Iff0e47f8bd2925cee9f42a2b309de4de84e99cad
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/108279
Commit-Queue: Vyacheslav Egorov <[email protected]>
Reviewed-by: Johnni Winther <[email protected]>

Author: mraleph

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

@@ -996,8 +996,14 @@ class AstBuilder extends StackListener {
   }
 
   @override
-  void endFormalParameter(Token thisKeyword, Token periodAfterThis,
-      Token nameToken, FormalParameterKind kind, MemberKind memberKind) {
+  void endFormalParameter(
+      Token thisKeyword,
+      Token periodAfterThis,
+      Token nameToken,
+      Token initializerStart,
+      Token initializerEnd,
+      FormalParameterKind kind,
+      MemberKind memberKind) {
     assert(optionalOrNull('this', thisKeyword));
     assert(thisKeyword == null
         ? periodAfterThis == null

pkg/analyzer/test/generated/parser_fasta_listener.dart

@@ -762,11 +762,17 @@ class ForwardingTestListener extends ForwardingListener {
   }
 
   @override
-  void endFormalParameter(Token thisKeyword, Token periodAfterThis,
-      Token nameToken, FormalParameterKind kind, MemberKind memberKind) {
+  void endFormalParameter(
+      Token thisKeyword,
+      Token periodAfterThis,
+      Token nameToken,
+      Token initializerStart,
+      Token initializerEnd,
+      FormalParameterKind kind,
+      MemberKind memberKind) {
     end('FormalParameter');
-    super.endFormalParameter(
-        thisKeyword, periodAfterThis, nameToken, kind, memberKind);
+    super.endFormalParameter(thisKeyword, periodAfterThis, nameToken,
+        initializerStart, initializerEnd, kind, memberKind);
   }
 
   @override

pkg/analyzer/tool/summary/mini_ast.dart

@@ -297,8 +297,14 @@ class MiniAstBuilder extends StackListener {
   }
 
   @override
-  void endFormalParameter(Token thisKeyword, Token periodAfterThis,
-      Token nameToken, FormalParameterKind kind, MemberKind memberKind) {
+  void endFormalParameter(
+      Token thisKeyword,
+      Token periodAfterThis,
+      Token nameToken,
+      Token initializerStart,
+      Token initializerEnd,
+      FormalParameterKind kind,
+      MemberKind memberKind) {
     debugEvent("FormalParameter");
     pop(); // Name
     pop(); // Type

pkg/front_end/lib/src/fasta/builder/formal_parameter_builder.dart

@@ -50,4 +50,6 @@ abstract class FormalParameterBuilder<T extends TypeBuilder>
   String get fullNameForErrors => name;
 
   FormalParameterBuilder forFormalParameterInitializerScope();
+
+  void buildOutlineExpressions(LibraryBuilder library);
 }

pkg/front_end/lib/src/fasta/kernel/body_builder.dart

@@ -633,6 +633,7 @@ abstract class BodyBuilder extends ScopeListener<JumpTarget>
     ProcedureBuilder<TypeBuilder> member = this.member;
     scope = member.computeFormalParameterInitializerScope(scope);
     if (member is KernelConstructorBuilder) {
+      member.prepareInitializers();
       if (member.formals != null) {
         for (KernelFormalParameterBuilder formal in member.formals) {
           if (formal.isInitializingFormal) {
@@ -1128,6 +1129,16 @@ abstract class BodyBuilder extends ScopeListener<JumpTarget>
     return fakeReturn.expression;
   }
 
+  void parseInitializers(Token token) {
+    Parser parser = new Parser(this);
+    if (!token.isEof) {
+      token = parser.parseInitializers(token);
+      checkEmpty(token.charOffset);
+    } else {
+      handleNoInitializers();
+    }
+  }
+
   Expression parseFieldInitializer(Token token) {
     Parser parser = new Parser(this);
     token = parser.parseExpression(parser.syntheticPreviousToken(token));
@@ -2886,8 +2897,14 @@ abstract class BodyBuilder extends ScopeListener<JumpTarget>
   }
 
   @override
-  void endFormalParameter(Token thisKeyword, Token periodAfterThis,
-      Token nameToken, FormalParameterKind kind, MemberKind memberKind) {
+  void endFormalParameter(
+      Token thisKeyword,
+      Token periodAfterThis,
+      Token nameToken,
+      Token initializerStart,
+      Token initializerEnd,
+      FormalParameterKind kind,
+      MemberKind memberKind) {
     debugEvent("FormalParameter");
     if (thisKeyword != null) {
       if (!inConstructor) {

pkg/front_end/lib/src/fasta/kernel/kernel_body_builder.dart

@@ -59,8 +59,8 @@ class KernelBodyBuilder extends BodyBuilder {
             classBuilder,
             member?.isInstanceMember ?? false,
             fileUri,
-            library.loader.typeInferenceEngine
-                ?.createLocalTypeInferrer(fileUri, null, library));
+            library.loader.typeInferenceEngine?.createLocalTypeInferrer(
+                fileUri, classBuilder?.target?.thisType, library));
 
   @override
   void enterThenForTypePromotion(Expression condition) {

pkg/front_end/lib/src/fasta/kernel/kernel_field_builder.dart

@@ -109,7 +109,16 @@ class KernelFieldBuilder extends FieldBuilder<Expression> {
     ClassBuilder classBuilder = isClassMember ? parent : null;
     KernelMetadataBuilder.buildAnnotations(
         field, metadata, library, classBuilder, this);
-    if (constInitializerToken != null) {
+
+    // For modular compilation we need to include initializers of all const
+    // fields and all non-static final fields in classes with const constructors
+    // into the outline.
+    if ((isConst ||
+            (isFinal &&
+                !isStatic &&
+                isClassMember &&
+                classBuilder.hasConstConstructor)) &&
+        constInitializerToken != null) {
       Scope scope = classBuilder?.scope ?? library.scope;
       KernelBodyBuilder bodyBuilder =
           new KernelBodyBuilder.forOutlineExpression(
@@ -118,7 +127,6 @@ class KernelFieldBuilder extends FieldBuilder<Expression> {
           isConst ? ConstantContext.inferred : ConstantContext.none;
       initializer = bodyBuilder.parseFieldInitializer(constInitializerToken)
         ..parent = field;
-      constInitializerToken = null;
       bodyBuilder.typeInferrer
           ?.inferFieldInitializer(bodyBuilder, field.type, field.initializer);
       if (library.loader is SourceLoader) {
@@ -128,6 +136,7 @@ class KernelFieldBuilder extends FieldBuilder<Expression> {
       }
       bodyBuilder.resolveRedirectingFactoryTargets();
     }
+    constInitializerToken = null;
   }
 
   Field get target => field;

pkg/front_end/lib/src/fasta/kernel/kernel_formal_parameter_builder.dart

@@ -6,16 +6,28 @@ library fasta.kernel_formal_parameter_builder;
 
 import 'package:kernel/ast.dart' show VariableDeclaration;
 
+import '../constant_context.dart' show ConstantContext;
+
 import '../modifier.dart' show finalMask, initializingFormalMask;
 
+import '../scanner.dart' show Token;
+
+import '../scope.dart' show Scope;
+
+import '../source/source_loader.dart' show SourceLoader;
+
+import 'kernel_body_builder.dart' show KernelBodyBuilder;
+
 import 'kernel_builder.dart'
     show
         ClassBuilder,
         Declaration,
         FormalParameterBuilder,
+        KernelConstructorBuilder,
         KernelFieldBuilder,
         KernelLibraryBuilder,
         KernelTypeBuilder,
+        LibraryBuilder,
         MetadataBuilder,
         TypeBuilder;
 
@@ -25,6 +37,8 @@ class KernelFormalParameterBuilder
     extends FormalParameterBuilder<KernelTypeBuilder> {
   VariableDeclaration declaration;
 
+  Token initializerToken;
+
   KernelFormalParameterBuilder(
       List<MetadataBuilder> metadata,
       int modifiers,
@@ -83,4 +97,31 @@ class KernelFormalParameterBuilder
       }
     }
   }
+
+  @override
+  void buildOutlineExpressions(LibraryBuilder library) {
+    // For modular compilation we need to include initializers for all
+    // parameters of const constructors into the outline.
+    if (parent is KernelConstructorBuilder &&
+        parent.target.isConst &&
+        initializerToken != null) {
+      final ClassBuilder classBuilder = parent.parent;
+      Scope scope = classBuilder.scope;
+      KernelBodyBuilder bodyBuilder =
+          new KernelBodyBuilder.forOutlineExpression(
+              library, classBuilder, this, scope, fileUri);
+      bodyBuilder.constantContext = ConstantContext.required;
+      target.initializer = bodyBuilder.parseFieldInitializer(initializerToken)
+        ..parent = target;
+      bodyBuilder.typeInferrer?.inferParameterInitializer(
+          bodyBuilder, target.initializer, target.type);
+      if (library.loader is SourceLoader) {
+        SourceLoader loader = library.loader;
+        loader.transformPostInference(target, bodyBuilder.transformSetLiterals,
+            bodyBuilder.transformCollections);
+      }
+      bodyBuilder.resolveRedirectingFactoryTargets();
+    }
+    initializerToken = null;
+  }
 }

pkg/front_end/lib/src/fasta/kernel/kernel_library_builder.dart

@@ -704,7 +704,7 @@ class KernelLibraryBuilder
       currentDeclaration?.hasConstConstructor = true;
       // const constructors will have their initializers compiled and written
       // into the outline.
-      procedure.beginInitializers = beginInitializers;
+      procedure.beginInitializers = beginInitializers ?? Token.eof(-1);
     }
   }
 
@@ -901,12 +901,14 @@ class KernelLibraryBuilder
       KernelTypeBuilder type,
       String name,
       bool hasThis,
-      int charOffset) {
+      int charOffset,
+      Token initializerToken) {
     if (hasThis) {
       modifiers |= initializingFormalMask;
     }
     KernelFormalParameterBuilder formal = new KernelFormalParameterBuilder(
         metadata, modifiers, type, name, this, charOffset);
+    formal.initializerToken = initializerToken;
     if (legacyMode && hasThis && type == null) {
       (untypedInitializingFormals ??= <KernelFormalParameterBuilder>[])
           .add(formal);

pkg/front_end/lib/src/fasta/kernel/kernel_procedure_builder.dart

@@ -36,6 +36,8 @@ import 'package:kernel/type_algebra.dart' show containsTypeVariable, substitute;
 
 import '../../scanner/token.dart' show Token;
 
+import '../constant_context.dart' show ConstantContext;
+
 import '../loader.dart' show Loader;
 
 import '../messages.dart'
@@ -55,9 +57,13 @@ import '../problems.dart' show unexpected;
 
 import '../source/source_library_builder.dart' show SourceLibraryBuilder;
 
+import '../source/source_loader.dart' show SourceLoader;
+
 import '../type_inference/type_inference_engine.dart'
     show IncludesTypeParametersCovariantly;
 
+import 'kernel_body_builder.dart' show KernelBodyBuilder;
+
 import 'kernel_builder.dart'
     show
         ClassBuilder,
@@ -238,6 +244,22 @@ abstract class KernelFunctionBuilder
 
   Member build(SourceLibraryBuilder library);
 
+  @override
+  void buildOutlineExpressions(LibraryBuilder library) {
+    KernelMetadataBuilder.buildAnnotations(
+        target, metadata, library, isClassMember ? parent : null, this);
+
+    if (formals != null) {
+      // For const constructors we need to include default parameter values
+      // into the outline. For all other formals we need to call
+      // buildOutlineExpressions to clear initializerToken to prevent
+      // consuming too much memory.
+      for (FormalParameterBuilder<KernelTypeBuilder> formal in formals) {
+        formal.buildOutlineExpressions(library);
+      }
+    }
+  }
+
   void becomeNative(Loader loader) {
     Declaration constructor = loader.getNativeAnnotation();
     Arguments arguments =
@@ -359,12 +381,6 @@ class KernelProcedureBuilder extends KernelFunctionBuilder {
     return procedure;
   }
 
-  @override
-  void buildOutlineExpressions(LibraryBuilder library) {
-    KernelMetadataBuilder.buildAnnotations(
-        target, metadata, library, isClassMember ? parent : null, this);
-  }
-
   Procedure get target => origin.procedure;
 
   @override
@@ -491,8 +507,24 @@ class KernelConstructorBuilder extends KernelFunctionBuilder {
 
   @override
   void buildOutlineExpressions(LibraryBuilder library) {
-    KernelMetadataBuilder.buildAnnotations(
-        target, metadata, library, parent, this);
+    super.buildOutlineExpressions(library);
+
+    // For modular compilation purposes we need to include initializers
+    // for const constructors into the outline.
+    if (isConst && beginInitializers != null) {
+      ClassBuilder classBuilder = parent;
+      KernelBodyBuilder bodyBuilder =
+          new KernelBodyBuilder.forOutlineExpression(
+              library, classBuilder, this, classBuilder.scope, fileUri);
+      bodyBuilder.constantContext = ConstantContext.inferred;
+      bodyBuilder.parseInitializers(beginInitializers);
+      if (library.loader is SourceLoader) {
+        SourceLoader loader = library.loader;
+        loader.transformPostInference(target, bodyBuilder.transformSetLiterals,
+            bodyBuilder.transformCollections);
+      }
+      bodyBuilder.resolveRedirectingFactoryTargets();
+    }
     beginInitializers = null;
   }
 
@@ -601,6 +633,21 @@ class KernelConstructorBuilder extends KernelFunctionBuilder {
       reportPatchMismatch(patch);
     }
   }
+
+  void prepareInitializers() {
+    // For const constructors we parse initializers already at the outlining
+    // stage, there is no easy way to make body building stage skip initializer
+    // parsing, so we simply clear parsed initializers and rebuild them
+    // again.
+    // Note: this method clears both initializers from the target Kernel node
+    // and internal state associated with parsing initializers.
+    if (target.isConst) {
+      target.initializers.length = 0;
+      redirectingInitializer = null;
+      superInitializer = null;
+      hasMovedSuperInitializer = false;
+    }
+  }
 }
 
 class KernelRedirectingFactoryBuilder extends KernelProcedureBuilder {