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}) {

[Johnni Winther, 2015/04/12 11:10:45]

Nit: We would normally format this as:

ErroneousElement reportAndCreateErroneousElement(
    Node node,
    String name,
    MessageKind kind,
    Map arguments,
    {bool isError: false}) {
  ....

[Siggi Cherem (dart-lang), 2015/04/13 16:40:24]

Done.

BTW - It might be worth to start using the formatter at some point.

In the other projects were we did so, initially we found little quirks that we
would've done slightly different. For some, it was just matter of getting used
to a different style, for others we filed bugs to get the formatter fixed. But
beyond that initial phase, we really enjoy using it. It saves us time in
formatting things by hand and we have much less arguments about style in code
reviews :)

+    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()';
 }