Setup correct scope for initializers and complain about fields initialized more than once.

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

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library fasta.body_builder;
 
 import '../fasta_codes.dart'
     show FastaMessage, codeExpectedButGot, codeExpectedFunctionBody;
 
 import '../parser/parser.dart' show FormalParameterType, MemberKind, optional;
@@ skipping 60 matching lines @@
   final MemberBuilder member;
 
   final KernelClassBuilder classBuilder;
 
   final ClassHierarchy hierarchy;
 
   final CoreTypes coreTypes;
 
   final bool isInstanceMember;
 
-  final Map<String, FieldInitializer> fieldInitializers =
-      <String, FieldInitializer>{};
-
   final Scope enclosingScope;
 
   final bool enableNative;
 
   final bool isPlatformLibrary;
 
   @override
   final Uri uri;
 
   final TypeInferrer _typeInferrer;
@@ skipping 32 matching lines @@
   CloneVisitor cloner;
 
   bool constantExpressionRequired = false;
 
   DartType currentLocalVariableType;
 
   // Using non-null value to initialize this field based on performance advice
   // from VM engineers. TODO(ahe): Does this still apply?
   int currentLocalVariableModifiers = -1;
 
+  /// If non-null, records instance fields which have already been initialized
+  /// and where that was.
+  Map<String, int> initializedFields;
+
   BodyBuilder(
       KernelLibraryBuilder library,
       this.member,
       Scope scope,
       this.formalParameterScope,
       this.hierarchy,
       this.coreTypes,
       this.classBuilder,
       this.isInstanceMember,
       this.uri,
@@ skipping 239 matching lines @@
     if (beginToken == null) {
       assert(count == 0);
       push(NullValue.Block);
     } else {
       Block block = popBlock(count, beginToken);
       exitLocalScope();
       push(block);
     }
   }
 
-  @override
   void prepareInitializers() {
-    scope = formalParameterScope;
-    assert(fieldInitializers.isEmpty);
-    final member = this.member;
+    ProcedureBuilder member = this.member;
+    scope = member.computeFormalParameterInitializerScope(scope);
     if (member is KernelConstructorBuilder) {
-      Constructor constructor = member.constructor;
-      classBuilder.forEach((String name, Builder builder) {
-        if (builder is KernelFieldBuilder && builder.isInstanceMember) {
-          // TODO(ahe): Compute initializers (as in `field = initializer`).
-          fieldInitializers[name] = new FieldInitializer(builder.field, null)
-            ..parent = constructor;
-        }
-      });
       if (member.formals != null) {
         for (KernelFormalParameterBuilder formal in member.formals) {
           if (formal.hasThis) {
-            FieldInitializer initializer = fieldInitializers[formal.name];
-            if (initializer != null) {
-              fieldInitializers.remove(formal.name);
-              initializer.value = new VariableGet(formal.declaration)
-                ..parent = initializer;
-              member.addInitializer(initializer);
+            Initializer initializer;
+            if (member.isExternal) {
+              initializer = buildInvalidIntializer(
+                  buildCompileTimeError(
+                      "An external constructor can't initialize fields.",
+                      formal.charOffset),
+                  formal.charOffset);
+            } else {
+              initializer = buildFieldInitializer(formal.name,
+                  formal.charOffset, new VariableGet(formal.declaration));
             }
+            member.addInitializer(initializer);
           }
         }
       }
     }
   }
 
   @override
+  void handleNoInitializers() {
+    debugEvent("NoInitializers");
+    if (functionNestingLevel == 0) {
+      prepareInitializers();
+      scope = formalParameterScope;
+    }
+  }
+
+  @override
+  void beginInitializers(Token token) {
+    debugEvent("beginInitializers");
+    if (functionNestingLevel == 0) {
+      prepareInitializers();
+    }
+  }
+
+  @override
+  void endInitializers(int count, Token beginToken, Token endToken) {
+    debugEvent("Initializers");
+    if (functionNestingLevel == 0) {
+      scope = formalParameterScope;
+    }
+  }
+
+  @override
   void beginInitializer(Token token) {
     debugEvent("beginInitializer");
     inInitializer = true;
   }
 
   @override
   void endInitializer(Token token) {
     debugEvent("endInitializer");
     assert(!inInitializer);
     final member = this.member;
     var node = pop();
     Initializer initializer;
     if (node is Initializer) {
       initializer = node;
     } else if (node is FastaAccessor) {
-      initializer = node.buildFieldInitializer(fieldInitializers);
+      initializer = node.buildFieldInitializer(initializedFields);
     } else if (node is ConstructorInvocation) {
       initializer =
           buildSuperInitializer(node.target, node.arguments, token.charOffset);
     } else {
       Expression value = toValue(node);
       if (node is! Throw) {
         value = wrapInCompileTimeError(value, "Expected an initializer.");
       }
       initializer = buildInvalidIntializer(node, token.charOffset);
     }
     _typeInferrer.inferInitializer(initializer);
     if (member is KernelConstructorBuilder) {
       member.addInitializer(initializer);
     } else {
       addCompileTimeError(
           token.charOffset, "Can't have initializers: ${member.name}");
     }
   }
 
-  @override
-  void handleNoInitializers() {
-    debugEvent("NoInitializers");
-  }
-
-  @override
-  void endInitializers(int count, Token beginToken, Token endToken) {
-    debugEvent("Initializers");
-  }
-
   DartType _computeReturnTypeContext(MemberBuilder member) {
     if (member is KernelProcedureBuilder) {
       return member.target.function.returnType;
     } else {
       assert(member is KernelConstructorBuilder);
       return null;
     }
   }
 
   @override
@@ skipping 436 matching lines @@
             offsetForToken(token), "Not a constant expression.");
       }
       return new TypeDeclarationAccessor(this, builder, name, token);
     } else if (builder.isLocal) {
       if (constantExpressionRequired &&
           !builder.isConst &&
           !member.isConstructor) {
         addCompileTimeError(
             offsetForToken(token), "Not a constant expression.");
       }
-      return new VariableAccessor(this, token, builder.target);
+      // An initializing formal parameter might be final without its
+      // VariableDeclaration being final. See
+      // [ProcedureBuilder.computeFormalParameterInitializerScope]. If that
+      // wasn't the case, we could always use VariableAccessor.
+      if (builder.isFinal) {
+        var fact =
+            typePromoter.getFactForAccess(builder.target, functionNestingLevel);
+        var scope = typePromoter.currentScope;
+        return new ReadOnlyAccessor(
+            this,
+            new KernelVariableGet(builder.target, fact, scope)
+              ..fileOffset = offsetForToken(token),
+            name,
+            token);
+      } else {
+        return new VariableAccessor(this, token, builder.target);
+      }
     } else if (builder.isInstanceMember) {
       if (constantExpressionRequired &&
           !inInitializer &&
           // TODO(ahe): This is a hack because Fasta sets up the scope
           // "this.field" parameters according to old semantics. Under the new
           // semantics, such parameters introduces a new parameter with that
           // name that should be resolved here.
           !member.isConstructor) {
         addCompileTimeError(
             offsetForToken(token), "Not a constant expression.");
@@ skipping 648 matching lines @@
     if (inCatchClause) {
       modifiers |= finalMask;
     }
     bool isConst = (modifiers & constMask) != 0;
     bool isFinal = (modifiers & finalMask) != 0;
     ignore(Unhandled.Metadata);
     VariableDeclaration variable;
     if (!inCatchClause &&
         functionNestingLevel == 0 &&
         memberKind != MemberKind.GeneralizedFunctionType) {
-      dynamic builder = formalParameterScope.lookup(
-          name.name, offsetForToken(name.token), uri);
-      if (builder == null) {
-        if (thisKeyword == null) {
-          internalError("Internal error: formal missing for '${name.name}'");
-        } else {
-          addCompileTimeError(thisKeyword.charOffset,
-              "'${name.name}' isn't a field in this class.");
-          thisKeyword = null;
-        }
-      } else if (thisKeyword == null) {
-        variable = builder.build(library);
+      ProcedureBuilder member = this.member;
+      KernelFormalParameterBuilder formal = member.getFormal(name.name);
+      if (formal == null) {
+        internalError("Internal error: formal missing for '${name.name}'");
+      } else {
+        variable = formal.build(library);
         variable.initializer = name.initializer;
-      } else if (builder.isField && builder.parent == classBuilder) {
-        FieldBuilder field = builder;
-        if (type != null) {
-          nit("Ignoring type on 'this' parameter '${name.name}'.",
-              thisKeyword.charOffset);
-        }
-        type = field.target.type;
-        variable = new KernelVariableDeclaration(
-            name.name, functionNestingLevel,
-            type: type,
-            initializer: name.initializer,
-            isFinal: isFinal,
-            isConst: isConst)
-          ..fileOffset = offsetForToken(name.token);
-      } else {
-        addCompileTimeError(offsetForToken(name.token),
-            "'${name.name}' isn't a field in this class.");
+      }
+    } else {
+      variable = new KernelVariableDeclaration(name?.name, functionNestingLevel,
+          type: type,
+          initializer: name?.initializer,
+          isFinal: isFinal,
+          isConst: isConst);
+      if (name != null) {
+        // TODO(ahe): Need an offset when name is null.
+        variable.fileOffset = offsetForToken(name.token);
       }
     }
-    variable ??= new KernelVariableDeclaration(name?.name, functionNestingLevel,
-        type: type,
-        initializer: name?.initializer,
-        isFinal: isFinal,
-        isConst: isConst)
-      ..fileOffset = offsetForToken(name?.token);
     push(variable);
   }
 
   @override
   void endOptionalFormalParameters(
       int count, Token beginToken, Token endToken) {
     debugEvent("OptionalFormalParameters");
     FormalParameterType kind = optional("{", beginToken)
         ? FormalParameterType.NAMED
         : FormalParameterType.POSITIONAL;
@@ skipping 1031 matching lines @@
   }
 
   @override
   Initializer buildInvalidIntializer(Expression expression,
       [int charOffset = -1]) {
     needsImplicitSuperInitializer = false;
     return new LocalInitializer(new VariableDeclaration.forValue(expression))
       ..fileOffset = charOffset;
   }
 
+  Initializer buildDuplicatedInitializer(
+      String name, int offset, int previousInitializerOffset) {
+    Initializer initializer = buildInvalidIntializer(

[Johnni Winther, 2017/06/06 10:35:08]

buildInvalidIntializer ->  buildInvalidInitializer

[ahe, 2017/06/06 15:08:24]

Done.

+        buildCompileTimeError("'$name' has already been initialized.", offset),
+        offset);
+    addCompileTimeError(
+        initializedFields[name], "'$name' was initialized here.");
+    return initializer;
+  }
+
+  @override
+  Initializer buildFieldInitializer(
+      String name, int offset, Expression expression) {
+    Builder builder = classBuilder.scope.local[name];
+    if (builder is KernelFieldBuilder && builder.isInstanceMember) {
+      initializedFields ??= <String, int>{};
+      if (initializedFields.containsKey(name)) {
+        return buildDuplicatedInitializer(
+            name, offset, initializedFields[name]);
+      }
+      initializedFields[name] = offset;
+      if (builder.isFinal && builder.hasInitializer) {
+        // TODO(ahe): If CL 2843733002 is landed, this becomes a compile-time
+        // error. Also, this is a compile-time error in strong mode.
+        warningNotError(
+            "'$name' is final instance variable that has already been "
+            "initialized.",
+            offset);
+        warningNotError("'$name' was initialized here.", builder.charOffset);
+        Builder constructor =
+            library.loader.getDuplicatedFieldInitializerError();
+        return buildInvalidIntializer(
+            new Throw(buildStaticInvocation(constructor.target,
+                new Arguments(<Expression>[new StringLiteral(name)]),
+                charOffset: offset)),
+            offset);
+      } else {
+        return new FieldInitializer(builder.field, expression)
+          ..fileOffset = offset;
+      }
+    } else {
+      return buildInvalidIntializer(
+          buildCompileTimeError(
+              "'$name' isn't an instance field of this class.", offset),
+          offset);
+    }
+  }
+
   @override
   Initializer buildSuperInitializer(
       Constructor constructor, Arguments arguments,
       [int charOffset = -1]) {
     needsImplicitSuperInitializer = false;
     return new SuperInitializer(constructor, arguments)
       ..fileOffset = charOffset;
   }
 
   @override
@@ skipping 286 matching lines @@
       return accessor.buildCompoundAssignment(barName, value,
           offset: offsetForToken(token), voidContext: voidContext);
     } else if (identical("~/=", assignmentOperator)) {
       return accessor.buildCompoundAssignment(mustacheName, value,
           offset: offsetForToken(token), voidContext: voidContext);
     } else {
       return internalError("Unhandled: $assignmentOperator");
     }
   }
 
-  Initializer buildFieldInitializer(
-      Map<String, FieldInitializer> initializers) {
+  @override
+  Initializer buildFieldInitializer(Map<String, int> initializedFields) {
     if (!identical("=", assignmentOperator) ||
         !accessor.isThisPropertyAccessor) {
-      return accessor.buildFieldInitializer(initializers);
+      return accessor.buildFieldInitializer(initializedFields);
     }
-    String name = accessor.plainNameForRead;
-    FieldInitializer initializer = initializers[name];
-    if (initializer != null && initializer.value == null) {
-      initializers.remove(name);
-      initializer.value = value..parent = initializer;
-      return initializer;
-    }
-    return accessor.buildFieldInitializer(initializers);
+    return helper.buildFieldInitializer(
+        accessor.plainNameForRead, offsetForToken(token), value);
   }
 }
 
 class DelayedPostfixIncrement extends ContextAccessor {
   final Name binaryOperator;
 
   final Procedure interfaceTarget;
 
   DelayedPostfixIncrement(BuilderHelper helper, Token token,
       FastaAccessor accessor, this.binaryOperator, this.interfaceTarget)
@@ skipping 260 matching lines @@
     if (starToken == null) {
       return AsyncMarker.Async;
     } else {
       assert(identical(starToken.stringValue, "*"));
       return AsyncMarker.AsyncStar;
     }
   } else {
     return internalError("Unknown async modifier: $asyncToken");
   }
 }