[kernel] Add VariableDeclaration.hasDeclaredInitializer

The computation of default values on super parameters requires the
notion of a declared initializer. By adding this as a flag to
VariableDeclarations the implementation can now be normalized across
parameter from source and dill.

TEST=existing

Change-Id: Ic980e68b569e3bdab38d2c7c7e4374e0c931a87b
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/240403
Reviewed-by: Aske Simon Christensen <askesc@google.com>
Reviewed-by: Chloe Stefantsova <cstefantsova@google.com>
Commit-Queue: Johnni Winther <johnniwinther@google.com>

Author: johnniwinther

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

@@ -1589,14 +1589,6 @@ class VariableDeclarationImpl extends VariableDeclaration {
   /// the kernel.
   final bool isImplicitlyTyped;
 
-  /// True if the initializer was specified by the programmer.
-  ///
-  /// Note that the variable might have a synthesized initializer expression,
-  /// so `hasDeclaredInitializer == false` doesn't imply `initializer == null`.
-  /// For instance, for duplicate variable names, an invalid expression is set
-  /// as the initializer of the second variable.
-  final bool hasDeclaredInitializer;
-
   // TODO(ahe): Remove this field. We can get rid of it by recording closure
   // mutation in [BodyBuilder].
   final int functionNestingLevel;
@@ -1625,7 +1617,7 @@ class VariableDeclarationImpl extends VariableDeclaration {
 
   VariableDeclarationImpl(String? name, this.functionNestingLevel,
       {this.forSyntheticToken: false,
-      this.hasDeclaredInitializer: false,
+      bool hasDeclaredInitializer: false,
       Expression? initializer,
       DartType? type,
       bool isFinal: false,
@@ -1648,15 +1640,15 @@ class VariableDeclarationImpl extends VariableDeclaration {
             isCovariantByDeclaration: isCovariantByDeclaration,
             isLate: isLate,
             isRequired: isRequired,
-            isLowered: isLowered);
+            isLowered: isLowered,
+            hasDeclaredInitializer: hasDeclaredInitializer);
 
   VariableDeclarationImpl.forEffect(Expression initializer)
       : forSyntheticToken = false,
         functionNestingLevel = 0,
         isImplicitlyTyped = false,
         isLocalFunction = false,
         isStaticLate = false,
-        hasDeclaredInitializer = true,
         super.forValue(initializer);
 
   VariableDeclarationImpl.forValue(Expression initializer)
@@ -1665,7 +1657,6 @@ class VariableDeclarationImpl extends VariableDeclaration {
         isImplicitlyTyped = true,
         isLocalFunction = false,
         isStaticLate = false,
-        hasDeclaredInitializer = true,
         super.forValue(initializer);
 
   // The synthesized local getter function for a lowered late variable.

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

@@ -225,6 +225,7 @@ class DelayedDefaultValueCloner {
             synthesizedParameterType, SubtypeCheckMode.withNullabilities)) {
       _cloneInitializer(originalParameter, synthesizedParameter);
     } else {
+      synthesizedParameter.hasDeclaredInitializer = false;
       if (synthesizedParameterType.isPotentiallyNonNullable) {
         _libraryBuilder.addProblem(
             templateOptionalSuperParameterWithoutInitializer.withArguments(
@@ -260,10 +261,14 @@ class TypeDependency {
     for (int i = 0; i < original.function!.positionalParameters.length; i++) {
       VariableDeclaration synthesizedParameter =
           synthesized.function!.positionalParameters[i];
-      VariableDeclaration constructorParameter =
+      VariableDeclaration originalParameter =
           original.function!.positionalParameters[i];
       synthesizedParameter.type =
-          substitution.substituteType(constructorParameter.type);
+          substitution.substituteType(originalParameter.type);
+      if (!synthesizedParameter.hasDeclaredInitializer) {
+        synthesizedParameter.hasDeclaredInitializer =
+            originalParameter.hasDeclaredInitializer;
+      }
     }
     for (int i = 0; i < original.function!.namedParameters.length; i++) {
       VariableDeclaration synthesizedParameter =
@@ -272,6 +277,10 @@ class TypeDependency {
           original.function!.namedParameters[i];
       synthesizedParameter.type =
           substitution.substituteType(originalParameter.type);
+      if (!synthesizedParameter.hasDeclaredInitializer) {
+        synthesizedParameter.hasDeclaredInitializer =
+            originalParameter.hasDeclaredInitializer;
+      }
     }
     if (copyReturnType) {
       synthesized.function!.returnType =

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

@@ -1001,6 +1001,7 @@ class KernelTarget extends TargetImplementation {
       VariableDeclaration copy = new VariableDeclaration(formal.name,
           isFinal: formal.isFinal,
           isConst: formal.isConst,
+          hasDeclaredInitializer: formal.hasDeclaredInitializer,
           type: const UnknownType());
       if (!hasTypeDependency && formal.type is! UnknownType) {
         copy.type = substitution.substituteType(formal.type);

pkg/front_end/lib/src/fasta/source/source_constructor_builder.dart

@@ -330,17 +330,10 @@ class DeclaredSourceConstructorBuilder extends SourceFunctionBuilderImpl
     }
 
     Constructor superTarget;
-    List<FormalParameterBuilder>? superFormals;
     FunctionNode? superConstructorFunction;
-    if (superTargetBuilder is DeclaredSourceConstructorBuilder) {
-      superTarget = superTargetBuilder.constructor;
-      superFormals = superTargetBuilder.formals!;
-    } else if (superTargetBuilder is DillConstructorBuilder) {
+    if (superTargetBuilder != null) {
       superTarget = superTargetBuilder.constructor;
       superConstructorFunction = superTargetBuilder.function;
-      if (superTargetBuilder is SyntheticSourceConstructorBuilder) {
-        superFormals = superTargetBuilder.formals;
-      }
     } else {
       // The error in this case should be reported elsewhere. Here we perform a
       // simple recovery.
@@ -351,53 +344,17 @@ class DeclaredSourceConstructorBuilder extends SourceFunctionBuilderImpl
     List<bool> positionalSuperFormalHasInitializer = [];
     Map<String, DartType?> namedSuperFormalType = {};
     Map<String, bool> namedSuperFormalHasInitializer = {};
-    // TODO(johnniwinther): Clean this up when [VariableDeclaration] has a
-    // `hasDeclaredInitializer` flag.
-    if (superFormals != null && superConstructorFunction != null) {
-      for (VariableDeclaration formal
-          in superConstructorFunction.positionalParameters) {
-        positionalSuperFormalType.add(formal.type);
-      }
-      for (VariableDeclaration formal
-          in superConstructorFunction.namedParameters) {
-        namedSuperFormalType[formal.name!] = formal.type;
-      }
-      for (FormalParameterBuilder formal in superFormals) {
-        if (formal.isPositional) {
-          positionalSuperFormalHasInitializer
-              .add(formal.hasDeclaredInitializer);
-        } else {
-          namedSuperFormalHasInitializer[formal.name] =
-              formal.hasDeclaredInitializer;
-        }
-      }
-    } else if (superFormals != null) {
-      for (FormalParameterBuilder formal in superFormals) {
-        if (formal.isPositional) {
-          positionalSuperFormalType.add(formal.variable?.type);
-          positionalSuperFormalHasInitializer
-              .add(formal.hasDeclaredInitializer);
-        } else {
-          namedSuperFormalType[formal.name] = formal.variable?.type;
-          namedSuperFormalHasInitializer[formal.name] =
-              formal.hasDeclaredInitializer;
-        }
-      }
-    } else if (superConstructorFunction != null) {
-      for (VariableDeclaration formal
-          in superConstructorFunction.positionalParameters) {
-        positionalSuperFormalType.add(formal.type);
-        positionalSuperFormalHasInitializer.add(formal.initializer != null);
-      }
-      for (VariableDeclaration formal
-          in superConstructorFunction.namedParameters) {
-        namedSuperFormalType[formal.name!] = formal.type;
-        namedSuperFormalHasInitializer[formal.name!] =
-            formal.initializer != null;
-      }
-    } else {
-      // The error is reported elsewhere.
-      return performRecoveryForErroneousCase();
+
+    for (VariableDeclaration formal
+        in superConstructorFunction.positionalParameters) {
+      positionalSuperFormalType.add(formal.type);
+      positionalSuperFormalHasInitializer.add(formal.hasDeclaredInitializer);
+    }
+    for (VariableDeclaration formal
+        in superConstructorFunction.namedParameters) {
+      namedSuperFormalType[formal.name!] = formal.type;
+      namedSuperFormalHasInitializer[formal.name!] =
+          formal.hasDeclaredInitializer;
     }
 
     int superInitializingFormalIndex = -1;
@@ -423,9 +380,12 @@ class DeclaredSourceConstructorBuilder extends SourceFunctionBuilderImpl
               positionalSuperFormalType.length);
           if (superInitializingFormalIndex <
               positionalSuperFormalHasInitializer.length) {
-            formal.hasDeclaredInitializer = hasImmediatelyDeclaredInitializer ||
-                positionalSuperFormalHasInitializer[
-                    superInitializingFormalIndex];
+            if (formal.isOptional) {
+              formal.hasDeclaredInitializer =
+                  hasImmediatelyDeclaredInitializer ||
+                      positionalSuperFormalHasInitializer[
+                          superInitializingFormalIndex];
+            }
             correspondingSuperFormalType =
                 positionalSuperFormalType[superInitializingFormalIndex];
             if (!hasImmediatelyDeclaredInitializer &&
@@ -439,8 +399,11 @@ class DeclaredSourceConstructorBuilder extends SourceFunctionBuilderImpl
           }
         } else {
           if (namedSuperFormalHasInitializer[formal.name] != null) {
-            formal.hasDeclaredInitializer = hasImmediatelyDeclaredInitializer ||
-                namedSuperFormalHasInitializer[formal.name]!;
+            if (formal.isOptional) {
+              formal.hasDeclaredInitializer =
+                  hasImmediatelyDeclaredInitializer ||
+                      namedSuperFormalHasInitializer[formal.name]!;
+            }
             correspondingSuperFormalType = namedSuperFormalType[formal.name];
             if (!hasImmediatelyDeclaredInitializer && !formal.isRequiredNamed) {
               (namedSuperParameters ??= <String>[]).add(formal.name);
@@ -457,6 +420,7 @@ class DeclaredSourceConstructorBuilder extends SourceFunctionBuilderImpl
           }
           formal.variable!.type = type ?? const DynamicType();
         }
+        formal.variable!.hasDeclaredInitializer = formal.hasDeclaredInitializer;
       }
     }
 

pkg/front_end/testcases/const_functions/const_functions_simple_invocations.dart.weak.outline.expect

@@ -19,9 +19,9 @@ static const field core::int multi = self::multiFn(1);
 static const field core::int multi2 = self::multiFn(2);
 static method binaryFn(core::int a, core::int b) → core::int
   ;
-static method optionalFn(core::int c, [core::int d]) → core::int
+static method optionalFn(core::int c, [has-declared-initializer core::int d]) → core::int
   ;
-static method namedFn(core::int e, {core::int f}) → core::int
+static method namedFn(core::int e, {has-declared-initializer core::int f}) → core::int
   ;
 static method typeFn<T extends core::Object? = dynamic>(self::typeFn::T% x) → self::typeFn::T%
   ;

pkg/front_end/testcases/constructor_tearoffs/bound_checks_in_type_literals.dart.weak.outline.expect

@@ -21,7 +21,7 @@ class C<T extends core::num> extends core::Object {
 static field core::Type test3;
 static method test() → dynamic
   ;
-static method test2([core::Type t]) → dynamic
+static method test2([has-declared-initializer core::Type t]) → dynamic
   ;
 static method main() → dynamic
   ;

pkg/front_end/testcases/constructor_tearoffs/inferred_constructor_tear_off.dart.weak.outline.expect

@@ -26,5 +26,5 @@ static method testInferred() → dynamic
   ;
 static method expect(dynamic expected, dynamic actual) → dynamic
   ;
-static method throws(() → dynamic f, {core::bool inSoundModeOnly}) → dynamic
+static method throws(() → dynamic f, {has-declared-initializer core::bool inSoundModeOnly}) → dynamic
   ;

pkg/front_end/testcases/constructor_tearoffs/lowering/const_redirect.dart.weak.outline.expect

@@ -30,9 +30,9 @@ class Class extends core::Object /*hasConstConstructor*/  {
   const constructor named({core::List<self::Const> constants = const <self::Const>[const self::_ConstImpl::•<dynamic>(), const self::_ConstImpl::•<dynamic>(), const self::_ConstImpl::•<core::String>()]}) → self::Class
     : self::Class::constants = constants, super core::Object::•()
     ;
-  static method _#new#tearOff({core::List<self::Const> constants}) → self::Class
+  static method _#new#tearOff({has-declared-initializer core::List<self::Const> constants}) → self::Class
     return new self::Class::•(constants: constants);
-  static method _#named#tearOff({core::List<self::Const> constants}) → self::Class
+  static method _#named#tearOff({has-declared-initializer core::List<self::Const> constants}) → self::Class
     return new self::Class::named(constants: constants);
 }
 abstract class Const extends core::Object {

pkg/front_end/testcases/constructor_tearoffs/lowering/constructor_tear_off.dart.weak.outline.expect

@@ -54,5 +54,5 @@ static method testArgs() → dynamic
   ;
 static method expect(dynamic expected, dynamic actual) → dynamic
   ;
-static method throws(() → dynamic f, {core::bool inSoundModeOnly}) → dynamic
+static method throws(() → dynamic f, {has-declared-initializer core::bool inSoundModeOnly}) → dynamic
   ;

pkg/front_end/testcases/constructor_tearoffs/lowering/constructor_tear_off_default_values.dart.weak.outline.expect

@@ -6,14 +6,14 @@ class Class1 extends core::Object {
   final field core::int field;
   constructor •([core::int field = 42]) → self::Class1
     ;
-  static method _#new#tearOff([core::int field]) → self::Class1
+  static method _#new#tearOff([has-declared-initializer core::int field]) → self::Class1
     return new self::Class1::•(field);
 }
 class Class2 extends core::Object {
   final field core::int field;
   constructor •({core::int field = 42}) → self::Class2
     ;
-  static method _#new#tearOff({core::int field}) → self::Class2
+  static method _#new#tearOff({has-declared-initializer core::int field}) → self::Class2
     return new self::Class2::•(field: field);
 }
 static final field core::bool inSoundMode;
@@ -23,5 +23,5 @@ static method testDefaultValues() → void
   ;
 static method expect(dynamic expected, dynamic actual) → dynamic
   ;
-static method throws(() → dynamic f, {core::bool inSoundModeOnly}) → dynamic
+static method throws(() → dynamic f, {has-declared-initializer core::bool inSoundModeOnly}) → dynamic
   ;