Handle more unqualified SendSets

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;
 
 /// The state of constants in resolutions.
 enum ConstantState {
   /// Expressions are not required to be constants.
   NON_CONSTANT,
@@ skipping 1671 matching lines @@
     return const AssertResult();
   }
 
   /// Handle access of a property of [name] on `this`, like `this.name` and
   /// `this.name()`, or `name` and `name()` in instance context.
   ResolutionResult handleThisPropertyAccess(Send node, Name name) {
     AccessSemantics semantics = const DynamicAccess.thisProperty();
     return handleDynamicAccessSemantics(node, name, semantics);
   }
 
+  /// Handle update of a property of [name] on `this`, like `this.name = b` and
+  /// `this.name++`, or `name = b` and `name++` in instance context.
+  ResolutionResult handleThisPropertyUpdate(
+      SendSet node, Name name, Element element) {
+    AccessSemantics semantics = const DynamicAccess.thisProperty();
+    return handleDynamicUpdateSemantics(node, name, element, semantics);
+  }
+
   /// Handle access on `this`, like `this()` and `this` when it is parsed as a
   /// [Send] node.
   ResolutionResult handleThisAccess(Send node) {
     AccessSemantics accessSemantics = const DynamicAccess.thisAccess();
     if (node.isCall) {
       CallStructure callStructure =
           resolveArguments(node.argumentsNode).callStructure;
       Selector selector = callStructure.callSelector;
       // TODO(johnniwinther): Handle invalid this access as an
       // [AccessSemantics].
@@ skipping 340 matching lines @@
       analyzeConstantDeferred(node, enforceConst: false);
 
       // TODO(johnniwinther): Avoid the need for a [Selector] here.
       registry.registerSendStructure(node,
           new GetStructure(semantics,
               new Selector(SelectorKind.GETTER, name, CallStructure.NO_ARGS)));
       return new ConstantResult(node, semantics.constant);
     }
   }
 
+  /// Handle access to a constant type literal of [type].
+  // TODO(johnniwinther): Remove [name] when [Selector] is not required for the
+  // the [GetStructure].
+  // TODO(johnniwinther): Remove [element] when it is no longer needed for
+  // evaluating constants.
+  ResolutionResult handleConstantTypeLiteralUpdate(
+      SendSet node,
+      Name name,
+      TypeDeclarationElement element,
+      DartType type,
+      ConstantAccess semantics) {
+    ErroneousElement error =
+        reportAndCreateErroneousElement(
+            node.selector, name.text, MessageKind.ASSIGNING_TYPE, const {});
+    registry.useElement(node, error);
+    registry.registerTypeLiteral(node, type);
+    registry.registerThrowNoSuchMethod();
+
+    return handleUpdate(node, name, semantics);
+  }
+
   /// Handle access to a type literal of a typedef. Like `F` or
   /// `F()` where 'F' is typedef.
   ResolutionResult handleTypedefTypeLiteralAccess(
       Send node,
       Name name,
       TypedefElement typdef) {
     typdef.ensureResolved(compiler);
     DartType type = typdef.rawType;
     ConstantExpression constant = new TypeConstantExpression(type);
     AccessSemantics semantics = new ConstantAccess.typedefTypeLiteral(constant);
     return handleConstantTypeLiteralAccess(node, name, typdef, type, semantics);
   }
 
   /// Handle access to a type literal of the type 'dynamic'. Like `dynamic` or
   /// `dynamic()`.
   ResolutionResult handleDynamicTypeLiteralAccess(Send node) {
     DartType type = const DynamicType();
     ConstantExpression constant = new TypeConstantExpression(
         // TODO(johnniwinther): Use [type] when evaluation of constants is done
         // directly on the constant expressions.
         node.isCall ? coreTypes.typeType : type);
     AccessSemantics semantics = new ConstantAccess.dynamicTypeLiteral(constant);
     return handleConstantTypeLiteralAccess(
         node, const PublicName('dynamic'), compiler.typeClass, type, semantics);
   }
 
+  /// Handle update to a type literal of the type 'dynamic'. Like `dynamic++` or
+  /// `dynamic = 0`.
+  ResolutionResult handleDynamicTypeLiteralUpdate(SendSet node) {
+    DartType type = const DynamicType();
+    ConstantExpression constant =
+        new TypeConstantExpression(const DynamicType());
+    AccessSemantics semantics = new ConstantAccess.dynamicTypeLiteral(constant);
+    // TODO(johnniwinther): Remove this when all constants are evaluated.
+    compiler.resolver.constantCompiler.evaluate(constant);
+
+    return handleConstantTypeLiteralUpdate(
+        node, const PublicName('dynamic'), compiler.typeClass, type, semantics);
+  }
+
   /// Handle access to a type literal of a class. Like `C` or
   /// `C()` where 'C' is class.
   ResolutionResult handleClassTypeLiteralAccess(
       Send node,
       Name name,
       ClassElement cls) {
     DartType type = cls.rawType;
     ConstantExpression constant = new TypeConstantExpression(type);
     AccessSemantics semantics = new ConstantAccess.classTypeLiteral(constant);
     return handleConstantTypeLiteralAccess(node, name, cls, type, semantics);
@@ skipping 128 matching lines @@
           new UniverseSelector(selector, null));
       sendStructure = new GetStructure(semantics, selector);
     }
     registry.registerSendStructure(node, sendStructure);
     // TODO(23998): Remove this when all information goes through
     // the [SendStructure].
     registry.setSelector(node, selector);
     return const NoneResult();
   }
 
+  /// Handle dynamic update of [semantics].
+  ResolutionResult handleDynamicUpdateSemantics(
+      SendSet node, Name name, Element element, AccessSemantics semantics) {
+    Selector getterSelector =
+        new Selector(SelectorKind.GETTER, name, CallStructure.NO_ARGS);
+    Selector setterSelector =
+        new Selector(SelectorKind.SETTER, name.setter, CallStructure.ONE_ARG);
+    registry.registerDynamicSetter(
+        new UniverseSelector(setterSelector, null));
+    if (node.isComplex) {
+      registry.registerDynamicGetter(
+          new UniverseSelector(getterSelector, null));
+    }
+
+    // TODO(23998): Remove these when elements are only accessed through the
+    // send structure.
+    Element getter = element;
+    Element setter = element;
+    if (element != null && element.isAbstractField) {
+      AbstractFieldElement abstractField = element;
+      getter = abstractField.getter;
+      setter = abstractField.setter;
+    }
+    if (setter != null) {
+      registry.useElement(node, setter);
+      if (getter != null && node.isComplex) {
+        registry.useElement(node.selector, getter);
+      }
+    }
+
+    return handleUpdate(node, name, semantics);
+  }
+
   /// Handle dynamic property access, like `a.b` or `a.b()` where `a` is not a
   /// prefix or class.
   ResolutionResult handleDynamicPropertyAccess(Send node, Name name) {
     AccessSemantics semantics = const DynamicAccess.dynamicProperty();
     return handleDynamicAccessSemantics(node, name, semantics);
   }
 
   /// Handle conditional access, like `a?.b` or `a?.b()`.
   ResolutionResult handleConditionalAccess(Send node, Name name) {
     Node receiver = node.receiver;
@@ skipping 414 matching lines @@
       return handleAmbiguousUpdate(node, name, element);
     }
     if (element.isErroneous) {
       // This handles elements with parser errors.
       // TODO(johnniwinther): Elements with parse error should not set
       // [isErroneous] to `true`.
       assert(invariant(node, element is! ErroneousElement,
           message: "Unexpected erroneous element $element."));
       return handleUpdate(node, name,new StaticAccess.unresolved(element));
     }
+    if (element.isInstanceMember) {
+      if (inInstanceContext) {
+        return handleThisPropertyUpdate(node, name, element);
+      }
+    }
     return oldVisitSendSet(node);
   }
 
   /// Handle an unqualified [Send], that is where the `node.receiver` is null,
   /// like `a`, `a()`, `this()`, `assert()`, and `(){}()`.
   ResolutionResult handleUnqualifiedSend(Send node) {
     Identifier selector = node.selector.asIdentifier();
     if (selector == null) {
       // `(){}()` and `(foo)()`.
       return handleExpressionInvoke(node);
@@ skipping 28 matching lines @@
   }
 
   /// Handle an unqualified [SendSet], that is where the `node.receiver` is
   /// null, like `a = b`, `a++`, and `a += b`.
   ResolutionResult handleUnqualifiedSendSet(SendSet node) {
     Identifier selector = node.selector.asIdentifier();
     String text = selector.source;
     Name name = new Name(text, enclosingElement.library);
     Element element = lookupInScope(compiler, node, scope, text);
     if (element == null) {
+      if (text == 'dynamic') {
+        // `dynamic = b`, `dynamic++`, or `dynamic += b` where 'dynamic' is not
+        // declared in the current scope.
+        return handleDynamicTypeLiteralUpdate(node);
+      } else if (inInstanceContext) {
+        // Left-hand side is implicitly `this.name`.
+        return handleThisPropertyUpdate(node, name, null);
+      } else {
+        // Create [ErroneousElement] for unresolved access.
+        ErroneousElement error = reportCannotResolve(node, text);
+        return handleUpdate(node, name, new StaticAccess.unresolved(error));
+      }
       return oldVisitSendSet(node);
     } else {
       return handleResolvedSendSet(node, name, element);
     }
   }
 
   ResolutionResult visitSend(Send node) {
     if (node.isOperator) {
       // `a && b`, `a + b`, `-a`, or `a is T`.
       return handleOperatorSend(node);
@@ skipping 250 matching lines @@
     Selector getterSelector = new Selector(
         SelectorKind.GETTER, name, CallStructure.NO_ARGS);
     Selector setterSelector = new Selector(
         SelectorKind.SETTER, name.setter, CallStructure.ONE_ARG);
     AccessSemantics semantics = checkSuperAccess(node);
     if (node.isPrefix || node.isPostfix) {
       // `super.a++` or `++super.a`.
       if (semantics == null) {
         semantics = computeSuperAccessSemanticsForSelectors(
             node, getterSelector, setterSelector);
+        registry.registerStaticInvocation(semantics.getter);
+        registry.registerStaticInvocation(semantics.setter);
       }
       return handleUpdate(node, name, semantics);
     } else {
       AssignmentOperator operator = AssignmentOperator.parse(operatorText);
       if (operator.kind == AssignmentOperatorKind.ASSIGN) {
         // `super.a = b`.
         if (semantics == null) {
           semantics =
               computeSuperAccessSemanticsForSelector(
                   node, setterSelector, alternateName: name);
+          registry.registerStaticInvocation(semantics.setter);
           switch (semantics.kind) {
             case AccessKind.SUPER_FINAL_FIELD:
               compiler.reportWarning(
                   node,
                   MessageKind.ASSIGNING_FINAL_FIELD_IN_SUPER,
                   {'name': name,
                    'superclassName': semantics.setter.enclosingClass.name});
+              // TODO(johnniwinther): This shouldn't be needed.
               registry.registerDynamicInvocation(
                   new UniverseSelector(setterSelector, null));
               registry.registerSuperNoSuchMethod();
               break;
             case AccessKind.SUPER_METHOD:
               compiler.reportWarning(
                   node, MessageKind.ASSIGNING_METHOD_IN_SUPER,
                   {'name': name,
                    'superclassName': semantics.setter.enclosingClass.name});
+              // TODO(johnniwinther): This shouldn't be needed.
               registry.registerDynamicInvocation(
                   new UniverseSelector(setterSelector, null));
               registry.registerSuperNoSuchMethod();
               break;
             default:
               registry.registerStaticInvocation(semantics.setter);
               break;
           }
         }
         return handleUpdate(node, name, semantics);
       } else {
         // `super.a += b`.
         if (semantics == null) {
           semantics = computeSuperAccessSemanticsForSelectors(
               node, getterSelector, setterSelector);
+          registry.registerStaticInvocation(semantics.getter);
+          registry.registerStaticInvocation(semantics.setter);
         }
         return handleUpdate(node, name, semantics);
       }
     }
   }
 
   /// Handle update of an entity defined by [semantics]. For instance `a = b`,
   /// `a++` or `a += b` where [semantics] describe `a`.
   ResolutionResult handleUpdate(
       SendSet node,
@@ skipping 10 matching lines @@
       IncDecOperator operator = IncDecOperator.parse(operatorText);
       Selector operatorSelector =
           new Selector.binaryOperator(operator.selectorName);
 
       // TODO(23998): Remove these when selectors are only accessed
       // through the send structure.
       registry.setGetterSelectorInComplexSendSet(node, getterSelector);
       registry.setSelector(node, setterSelector);
       registry.setOperatorSelectorInComplexSendSet(node, operatorSelector);
 
-      if (semantics.isAccessedStatically) {
-        registry.registerStaticInvocation(semantics.getter);
-        registry.registerStaticInvocation(semantics.setter);
-      }
       // TODO(23998): Remove these when elements are only accessed
       // through the send structure.
       registry.useElement(node, semantics.setter);
       registry.useElement(node.selector, semantics.getter);
 
       registry.registerDynamicInvocation(
           new UniverseSelector(operatorSelector, null));
 
       SendStructure sendStructure = node.isPrefix
           ? new PrefixStructure(
               semantics, operator, getterSelector, setterSelector)
           : new PostfixStructure(
               semantics, operator, getterSelector, setterSelector);
       registry.registerSendStructure(node, sendStructure);
-      return const NoneResult();
     } else {
       Node rhs = node.arguments.head;
       visitExpression(rhs);
 
       AssignmentOperator operator = AssignmentOperator.parse(operatorText);
       if (operator.kind == AssignmentOperatorKind.ASSIGN) {
         // `e1 = e2`.
-        if (semantics.isAccessedStatically) {
-          registry.registerStaticInvocation(semantics.setter);
-        }
 
         // TODO(23998): Remove these when elements are only accessed
         // through the send structure.
         registry.useElement(node, semantics.setter);
 
         // TODO(23998): Remove this when selectors are only accessed
         // through the send structure.
         registry.setSelector(node, setterSelector);
 
         SendStructure sendStructure =
             new SetStructure(semantics, setterSelector);
         registry.registerSendStructure(node, sendStructure);
-        return const NoneResult();
       } else {
         // `e1 += e2`.
         Selector operatorSelector =
             new Selector.binaryOperator(operator.selectorName);
-        if (semantics.isAccessedStatically) {
-          registry.registerStaticInvocation(semantics.getter);
-          registry.registerStaticInvocation(semantics.setter);
-        }
 
         // TODO(23998): Remove these when elements are only accessed
         // through the send structure.
         registry.useElement(node, semantics.setter);
         registry.useElement(node.selector, semantics.getter);
 
         // TODO(23998): Remove these when selectors are only accessed
         // through the send structure.
         registry.setGetterSelectorInComplexSendSet(node, getterSelector);
         registry.setSelector(node, setterSelector);
         registry.setOperatorSelectorInComplexSendSet(node, operatorSelector);
 
         registry.registerDynamicInvocation(
             new UniverseSelector(operatorSelector, null));
 
         SendStructure sendStructure = new CompoundStructure(
                 semantics, operator, getterSelector, setterSelector);
         registry.registerSendStructure(node, sendStructure);
-        return const NoneResult();
       }
     }
+    return new ResolutionResult.forElement(semantics.setter);
   }
 
   ResolutionResult visitSendSet(SendSet node) {
     if (node.isIndex) {
       if (node.isSuperCall) {
         return handleSuperIndexSendSet(node);
       } else {
         return handleIndexSendSet(node);
       }
     } else if (node.isSuperCall) {
@@ skipping 1289 matching lines @@
     }
     return const NoneResult();
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(Compiler compiler, Node node,
                       Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), compiler, node);
 }