Report compile-time error if using `this` implicitly in initializers

pkg/compiler/lib/src/resolution/members.dart

 // Copyright (c) 2012, 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.
 
 part of resolution;
 
 abstract class TreeElements {
   AnalyzableElement get analyzedElement;
   Iterable<Node> get superUses;
 
@@ skipping 2094 matching lines @@
  * Do not subclass or instantiate this class outside this library
  * except for testing.
  */
 class ResolverVisitor extends MappingVisitor<ResolutionResult> {
   /**
    * The current enclosing element for the visited AST nodes.
    *
    * This field is updated when nested closures are visited.
    */
   Element enclosingElement;
+
+  /// Whether we are in a context where `this` is accessible (this will be false
+  /// in static contexts, factory methods, and field initializers).
   bool inInstanceContext;
   bool inCheckContext;
   bool inCatchBlock;
 
   Scope scope;
   ClassElement currentClass;
   ExpressionStatement currentExpressionStatement;
   bool sendIsMemberAccess = false;
   StatementScope statementScope;
   int allowedCategory = ElementCategory.VARIABLE | ElementCategory.FUNCTION
@@ skipping 130 matching lines @@
     promotionScope = promotionScope.prepend(node);
     var result = action();
     promotionScope = promotionScope.tail;
     return result;
   }
 
   visitInStaticContext(Node node) {
     inStaticContext(() => visit(node));
   }
 
-  ErroneousElement warnAndCreateErroneousElement(Node node,
-                                                 String name,
-                                                 MessageKind kind,
-                                                 [Map arguments = const {}]) {
-    compiler.reportWarning(node, kind, arguments);
+  ErroneousElement reportAndCreateErroneousElement(
+      Node node,
+      String name,
+      MessageKind kind,
+      Map arguments,
+      {bool isError: false}) {
+    if (isError) {
+      compiler.reportError(node, kind, arguments);
+    } else {
+      compiler.reportWarning(node, kind, arguments);
+    }
     // TODO(ahe): Use [allowedCategory] to synthesize a more precise subclass
     // of [ErroneousElementX]. For example, [ErroneousFieldElementX],
     // [ErroneousConstructorElementX], etc.
     return new ErroneousElementX(kind, arguments, name, enclosingElement);
   }
 
   ResolutionResult visitIdentifier(Identifier node) {
     if (node.isThis()) {
       if (!inInstanceContext) {
         error(node, MessageKind.NO_INSTANCE_AVAILABLE, {'name': node});
@@ skipping 13 matching lines @@
       if (Elements.isUnresolved(element) && name == 'dynamic') {
         // TODO(johnniwinther): Remove this hack when we can return more complex
         // objects than [Element] from this method.
         element = compiler.typeClass;
         // Set the type to be `dynamic` to mark that this is a type literal.
         registry.setType(node, const DynamicType());
       }
       element = reportLookupErrorIfAny(element, node, node.source);
       if (element == null) {
         if (!inInstanceContext) {
-          element = warnAndCreateErroneousElement(
-              node, node.source, MessageKind.CANNOT_RESOLVE,
-              {'name': node});
+          // We report an error within initializers because `this` is implicitly
+          // accessed when unqualified identifiers are not resolved.  For
+          // details, see section 16.14.3 of the spec (2nd edition):
+          //   An unqualified invocation `i` of the form `id(a1, ...)`
+          //   ...
+          //   If `i` does not occur inside a top level or static function, `i`
+          //   is equivalent to `this.id(a1 , ...)`.
+          bool inInitializer = enclosingElement.isGenerativeConstructor ||
+              (enclosingElement.isInstanceMember && enclosingElement.isField);
+          MessageKind kind = inInitializer
+              ? MessageKind.CANNOT_RESOLVE_IN_INITIALIZER
+              : MessageKind.CANNOT_RESOLVE;
+          element = reportAndCreateErroneousElement(node, node.source, kind,
+              {'name': node.source}, isError: inInitializer);
           registry.registerThrowNoSuchMethod();
         }
       } else if (element.isErroneous) {
         // Use the erroneous element.
       } else {
         if ((element.kind.category & allowedCategory) == 0) {
-          element = warnAndCreateErroneousElement(
-              node, name,
-              MessageKind.GENERIC,
+          element = reportAndCreateErroneousElement(
+              node, name, MessageKind.GENERIC,
               // TODO(ahe): Improve error message. Need UX input.
               {'text': "is not an expression $element"});
         }
       }
       if (!Elements.isUnresolved(element) && element.isClass) {
         ClassElement classElement = element;
         classElement.ensureResolved(compiler);
       }
       return new ElementResult(registry.useElement(node, element));
     }
@@ skipping 269 matching lines @@
         error(node.receiver, MessageKind.GENERIC,
               {'text': "Object has no superclass"});
         return null;
       }
       // TODO(johnniwinther): Ensure correct behavior if currentClass is a
       // patch.
       target = currentClass.lookupSuperSelector(selector);
       // [target] may be null which means invoking noSuchMethod on
       // super.
       if (target == null) {
-        target = warnAndCreateErroneousElement(
+        target = reportAndCreateErroneousElement(
             node, name, MessageKind.NO_SUCH_SUPER_MEMBER,
             {'className': currentClass, 'memberName': name});
         // We still need to register the invocation, because we might
         // call [:super.noSuchMethod:] which calls
         // [JSInvocationMirror._invokeOn].
         registry.registerDynamicInvocation(selector);
         registry.registerSuperNoSuchMethod();
       }
     } else if (resolvedReceiver == null ||
                Elements.isUnresolved(resolvedReceiver.element)) {
@@ skipping 18 matching lines @@
         // TODO(johnniwinther): With the simplified [TreeElements] invariant,
         // try to resolve injected elements if [currentClass] is in the patch
         // library of [receiverClass].
 
         // TODO(karlklose): this should be reported by the caller of
         // [resolveSend] to select better warning messages for getters and
         // setters.
         MessageKind kind = (target == null)
             ? MessageKind.MEMBER_NOT_FOUND
             : MessageKind.MEMBER_NOT_STATIC;
-        return new ElementResult(warnAndCreateErroneousElement(
+        return new ElementResult(reportAndCreateErroneousElement(
             node, name, kind,
             {'className': receiverClass.name, 'memberName': name}));
       } else if (isPrivateName(name) &&
                  target.library != enclosingElement.library) {
         registry.registerThrowNoSuchMethod();
-        return new ElementResult(warnAndCreateErroneousElement(
+        return new ElementResult(reportAndCreateErroneousElement(
             node, name, MessageKind.PRIVATE_ACCESS,
             {'libraryName': target.library.getLibraryOrScriptName(),
              'name': name}));
       }
     } else if (resolvedReceiver.element.isPrefix) {
       PrefixElement prefix = resolvedReceiver.element;
       target = prefix.lookupLocalMember(name);
       if (Elements.isUnresolved(target)) {
         registry.registerThrowNoSuchMethod();
-        return new ElementResult(warnAndCreateErroneousElement(
+        return new ElementResult(reportAndCreateErroneousElement(
             node, name, MessageKind.NO_SUCH_LIBRARY_MEMBER,
             {'libraryName': prefix.name, 'memberName': name}));
       } else if (target.isAmbiguous) {
         registry.registerThrowNoSuchMethod();
         AmbiguousElement ambiguous = target;
-        target = warnAndCreateErroneousElement(node, name,
-                                               ambiguous.messageKind,
-                                               ambiguous.messageArguments);
+        target = reportAndCreateErroneousElement(
+            node, name, ambiguous.messageKind, ambiguous.messageArguments);
         ambiguous.diagnose(enclosingElement, compiler);
         return new ElementResult(target);
       } else if (target.kind == ElementKind.CLASS) {
         ClassElement classElement = target;
         classElement.ensureResolved(compiler);
       }
     }
     return new ElementResult(target);
   }
 
@@ skipping 120 matching lines @@
     }
 
     if (target != null) {
       if (target.isErroneous) {
         registry.registerThrowNoSuchMethod();
       } else if (target.isAbstractField) {
         AbstractFieldElement field = target;
         target = field.getter;
         if (target == null && !inInstanceContext) {
           registry.registerThrowNoSuchMethod();
-          target =
-              warnAndCreateErroneousElement(node.selector, field.name,
-                                            MessageKind.CANNOT_RESOLVE_GETTER);
+          target = reportAndCreateErroneousElement(node.selector, field.name,
+              MessageKind.CANNOT_RESOLVE_GETTER, const {});
         }
       } else if (target.isTypeVariable) {
         ClassElement cls = target.enclosingClass;
         assert(enclosingElement.enclosingClass == cls);
         if (Elements.isInStaticContext(enclosingElement)) {
           compiler.reportError(node,
               MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER,
               {'typeVariableName': node.selector});
         }
         registry.registerClassUsingVariableExpression(cls);
@@ skipping 153 matching lines @@
     Element getter = target;
     String operatorName = node.assignmentOperator.source;
     String source = operatorName;
     bool isComplex = !identical(source, '=');
     if (!(result is AssertResult || Elements.isUnresolved(target))) {
       if (target.isAbstractField) {
         AbstractFieldElement field = target;
         setter = field.setter;
         getter = field.getter;
         if (setter == null && !inInstanceContext) {
-          setter = warnAndCreateErroneousElement(
-              node.selector, field.name, MessageKind.CANNOT_RESOLVE_SETTER);
+          setter = reportAndCreateErroneousElement(node.selector, field.name,
+              MessageKind.CANNOT_RESOLVE_SETTER, const {});
           registry.registerThrowNoSuchMethod();
         }
         if (isComplex && getter == null && !inInstanceContext) {
-          getter = warnAndCreateErroneousElement(
-              node.selector, field.name, MessageKind.CANNOT_RESOLVE_GETTER);
+          getter = reportAndCreateErroneousElement(node.selector, field.name,
+              MessageKind.CANNOT_RESOLVE_GETTER, const {});
           registry.registerThrowNoSuchMethod();
         }
       } else if (target.impliesType) {
-        setter = warnAndCreateErroneousElement(
-            node.selector, target.name, MessageKind.ASSIGNING_TYPE);
+        setter = reportAndCreateErroneousElement(node.selector, target.name,
+            MessageKind.ASSIGNING_TYPE, const {});
         registry.registerThrowNoSuchMethod();
       } else if (target.isFinal ||
                  target.isConst ||
                  (target.isFunction &&
                   Elements.isStaticOrTopLevelFunction(target) &&
                   !target.isSetter)) {
         if (target.isFunction) {
-          setter = warnAndCreateErroneousElement(
-              node.selector, target.name, MessageKind.ASSIGNING_METHOD);
+          setter = reportAndCreateErroneousElement(node.selector, target.name,
+              MessageKind.ASSIGNING_METHOD, const {});
         } else {
-          setter = warnAndCreateErroneousElement(
-              node.selector, target.name, MessageKind.CANNOT_RESOLVE_SETTER);
+          setter = reportAndCreateErroneousElement(node.selector, target.name,
+              MessageKind.CANNOT_RESOLVE_SETTER, const {});
         }
         registry.registerThrowNoSuchMethod();
       }
       if (isPotentiallyMutableTarget(target)) {
         registry.registerPotentialMutation(target, node);
         if (enclosingElement != target.enclosingElement) {
           registry.registerPotentialMutationInClosure(target, node);
         }
         for (Node scope in promotionScope) {
           registry.registerPotentialMutationIn(scope, target, node);
@@ skipping 10 matching lines @@
         getterSelector = new Selector.getterFrom(selector);
       } else {
         assert(selector.isIndexSet);
         getterSelector = new Selector.index();
       }
       registerSend(getterSelector, getter);
       registry.setGetterSelectorInComplexSendSet(node, getterSelector);
       if (node.isSuperCall) {
         getter = currentClass.lookupSuperSelector(getterSelector);
         if (getter == null) {
-          target = warnAndCreateErroneousElement(
+          target = reportAndCreateErroneousElement(
               node, selector.name, MessageKind.NO_SUCH_SUPER_MEMBER,
               {'className': currentClass, 'memberName': selector.name});
           registry.registerSuperNoSuchMethod();
         }
       }
       registry.useElement(node.selector, getter);
 
       // Make sure we include the + and - operators if we are using
       // the ++ and -- ones.  Also, if op= form is used, include op itself.
       void registerBinaryOperator(String name) {
@@ skipping 2047 matching lines @@
 }
 
 /// The result for the resolution of the `assert` method.
 class AssertResult implements ResolutionResult {
   const AssertResult();
 
   Element get element => null;
 
   String toString() => 'AssertResult()';
 }