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

pkg/front_end/lib/src/fasta/kernel/fasta_accessors.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.fasta_accessors;
 
 import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart'
     show KernelArguments;
 
 import 'package:front_end/src/fasta/kernel/utils.dart' show offsetForToken;
@@ skipping 55 matching lines @@
 
   Member lookupSuperMember(Name name, {bool isSetter});
 
   scopeLookup(Scope scope, String name, Token token,
       {bool isQualified: false, PrefixBuilder prefix});
 
   finishSend(Object receiver, Arguments arguments, int offset);
 
   Expression buildCompileTimeError(error, [int offset]);
 
-  Initializer buildInvalidIntializer(Expression expression, [int offset]);
+  Initializer buildInvalidInitializer(Expression expression, [int offset]);
+
+  Initializer buildFieldInitializer(
+      String name, int offset, Expression expression);
 
   Initializer buildSuperInitializer(
       Constructor constructor, Arguments arguments,
       [int offset]);
 
   Initializer buildRedirectingInitializer(
       Constructor constructor, Arguments arguments,
       [int charOffset = -1]);
 
   Expression buildStaticInvocation(Procedure target, Arguments arguments);
@@ skipping 29 matching lines @@
   String get plainNameForRead;
 
   Uri get uri => helper.uri;
 
   String get plainNameForWrite => plainNameForRead;
 
   bool get isInitializer => false;
 
   Expression buildForEffect() => buildSimpleRead();
 
-  Initializer buildFieldInitializer(
-      Map<String, FieldInitializer> initializers) {
+  Initializer buildFieldInitializer(Map<String, int> initializedFields) {
     int offset = offsetForToken(token);
-    return helper.buildInvalidIntializer(
+    return helper.buildInvalidInitializer(
         helper.buildCompileTimeError(
             // TODO(ahe): This error message is really bad.
             "Can't use $plainNameForRead here.",
             offset),
         offset);
   }
 
   Expression makeInvalidRead() {
     return buildThrowNoSuchMethodError(new Arguments.empty(), isGetter: true);
   }
@@ skipping 45 matching lines @@
       {bool isGetter: false, bool isSetter: false, int offset});
 
   Name get name => internalError("Unsupported operation.");
 
   @override
   String get plainNameForRead => name.name;
 
   withReceiver(Object receiver, int operatorOffset, {bool isNullAware}) => this;
 
   @override
-  Initializer buildFieldInitializer(
-      Map<String, FieldInitializer> initializers) {
-    return helper.buildInvalidIntializer(
+  Initializer buildFieldInitializer(Map<String, int> initializedFields) {
+    return helper.buildInvalidInitializer(
         buildError(new Arguments.empty(), isSetter: true));
   }
 
   @override
   doInvocation(int offset, Arguments arguments) {
     return buildError(arguments, offset: offset);
   }
 
   @override
   buildPropertyAccess(
@@ skipping 78 matching lines @@
 
   Expression buildSimpleRead() {
     if (!isSuper) {
       return new ThisExpression();
     } else {
       return helper.buildCompileTimeError(
           "Can't use `super` as an expression.", offsetForToken(token));
     }
   }
 
-  Initializer buildFieldInitializer(
-      Map<String, FieldInitializer> initializers) {
+  @override
+  Initializer buildFieldInitializer(Map<String, int> initializedFields) {
     String keyword = isSuper ? "super" : "this";
     int offset = offsetForToken(token);
-    return helper.buildInvalidIntializer(
+    return helper.buildInvalidInitializer(
         helper.buildCompileTimeError(
             "Can't use '$keyword' here, did you mean '$keyword()'?", offset),
         offset);
   }
 
   buildPropertyAccess(
       IncompleteSend send, int operatorOffset, bool isNullAware) {
     if (isInitializer && send is SendAccessor) {
       return buildConstructorInitializer(
           offsetForToken(send.token), send.name, send.arguments);
@@ skipping 28 matching lines @@
           new ThisExpression(), callName, arguments, offset);
     }
   }
 
   Initializer buildConstructorInitializer(
       int offset, Name name, Arguments arguments) {
     Constructor constructor = helper.lookupConstructor(name, isSuper: isSuper);
     if (constructor == null ||
         !helper.checkArguments(
             constructor.function, arguments, <TypeParameter>[])) {
-      return helper.buildInvalidIntializer(
+      return helper.buildInvalidInitializer(
           buildThrowNoSuchMethodError(arguments,
               isSuper: isSuper, name: name.name, offset: offset),
           offset);
     } else if (isSuper) {
       return helper.buildSuperInitializer(constructor, arguments, offset);
     } else {
       return helper.buildRedirectingInitializer(constructor, arguments, offset);
     }
   }
 
@@ skipping 412 matching lines @@
 
   String get plainNameForRead => name.name;
 
   Expression doInvocation(int offset, Arguments arguments) {
     return internalError("Not implemented yet.");
   }
 
   toString() => "NullAwarePropertyAccessor()";
 }
 
+int adjustForImplicitCall(String name, int offset) {
+  // Normally the offset is at the start of the token, but in this case,
+  // because we insert a '.call', we want it at the end instead.
+  return offset + (name?.length ?? 0);
+}
+
 class VariableAccessor extends kernel.VariableAccessor with FastaAccessor {
   VariableAccessor(
       BuilderHelper helper, Token token, VariableDeclaration variable,
       [DartType promotedType])
       : super(helper, variable, promotedType, token);
 
   String get plainNameForRead => variable.name;
 
   Expression doInvocation(int offset, Arguments arguments) {
-    // Normally the offset is at the start of the token, but in this case,
-    // because we insert a '.call', we want it at the end instead.
     return helper.buildMethodInvocation(buildSimpleRead(), callName, arguments,
-        offset + (variable.name?.length ?? 0));
+        adjustForImplicitCall(plainNameForRead, offset));
   }
 
   toString() => "VariableAccessor()";
 }
 
 class ReadOnlyAccessor extends kernel.ReadOnlyAccessor with FastaAccessor {
   final String plainNameForRead;
 
   ReadOnlyAccessor(BuilderHelper helper, Expression expression,
       this.plainNameForRead, Token token)
       : super(helper, expression, token);
 
   Expression doInvocation(int offset, Arguments arguments) {
-    return helper.buildMethodInvocation(
-        buildSimpleRead(), callName, arguments, offset);
+    return helper.buildMethodInvocation(buildSimpleRead(), callName, arguments,
+        adjustForImplicitCall(plainNameForRead, offset));
   }
 }
 
 class ParenthesizedExpression extends ReadOnlyAccessor {
   ParenthesizedExpression(
       BuilderHelper helper, Expression expression, Token token)
-      : super(helper, expression, "<a parenthesized expression>", token);
+      : super(helper, expression, null, token);
 
   Expression makeInvalidWrite(Expression value) {
     return helper.buildCompileTimeError(
         "Can't assign to a parenthesized expression.", offsetForToken(token));
   }
 }
 
 class TypeDeclarationAccessor extends ReadOnlyAccessor {
   final TypeDeclarationBuilder declaration;
 
@@ skipping 103 matching lines @@
       {bool isGetter: false, bool isSetter: false, int offset}) {
     return helper.throwNoSuchMethodError(
         plainNameForRead, arguments, offset ?? offsetForToken(this.token),
         isGetter: isGetter, isSetter: isSetter);
   }
 }
 
 bool isFieldOrGetter(Member member) {
   return member is Field || (member is Procedure && member.isGetter);
 }