Refactor and clean up AccessSemantics

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 1322 matching lines @@
         // whether it is erroneous.
         if (semantics.kind == AccessKind.SUPER_METHOD) {
           registry.registerStaticUse(semantics.element.declaration);
         }
         // TODO(23998): Remove this when all information goes through
         // the [SendStructure].
         registry.useElement(node, semantics.element);
       }
     } else {
       ResolutionResult expressionResult = visitExpression(expression);
-      semantics = new DynamicAccess.dynamicProperty(expression);
+      semantics = const DynamicAccess.dynamicProperty();
       registry.registerDynamicInvocation(new UniverseSelector(selector, null));
 
       if (expressionResult.isConstant) {
         bool isValidConstant;
         ConstantExpression expressionConstant = expressionResult.constant;
         DartType knownExpressionType =
             expressionConstant.getKnownType(coreTypes);
         switch (operator.kind) {
           case UnaryOperatorKind.COMPLEMENT:
             isValidConstant =
@@ skipping 25 matching lines @@
     return result;
   }
 
   /// Handle a not expression, like `!a`.
   ResolutionResult handleNot(Send node, UnaryOperator operator) {
     assert(invariant(node, operator.kind == UnaryOperatorKind.NOT));
 
     Node expression = node.receiver;
     ResolutionResult result = visitExpression(expression);
     registry.registerSendStructure(node,
-        new NotStructure(new DynamicAccess.dynamicProperty(expression)));
+        new NotStructure(const DynamicAccess.dynamicProperty()));
 
     if (result.isConstant) {
       ConstantExpression expressionConstant = result.constant;
       if (expressionConstant.getKnownType(coreTypes) == coreTypes.boolType) {
         // TODO(johnniwinther): Handle potentially invalid constant expressions.
         ConstantExpression constant =
             new UnaryConstantExpression(operator, expressionConstant);
         registry.setConstant(node, constant);
         return new ConstantResult(node, constant);
       }
@@ skipping 109 matching lines @@
         }
         // TODO(23998): Remove this when all information goes through
         // the [SendStructure].
         registry.useElement(node, semantics.element);
       }
       visitExpression(right);
     } else {
       ResolutionResult leftResult = visitExpression(left);
       ResolutionResult rightResult = visitExpression(right);
       registry.registerDynamicInvocation(new UniverseSelector(selector, null));
-      semantics = new DynamicAccess.dynamicProperty(left);
+      semantics = const DynamicAccess.dynamicProperty();
 
       if (leftResult.isConstant && rightResult.isConstant) {
         bool isValidConstant;
         ConstantExpression leftConstant = leftResult.constant;
         ConstantExpression rightConstant = rightResult.constant;
         DartType knownLeftType = leftConstant.getKnownType(coreTypes);
         DartType knownRightType = rightConstant.getKnownType(coreTypes);
         switch (operator.kind) {
           case BinaryOperatorKind.EQ:
           case BinaryOperatorKind.NOT_EQ:
@@ skipping 113 matching lines @@
     Node expression = node.selector;
     visitExpression(expression);
     CallStructure callStructure =
         resolveArguments(node.argumentsNode).callStructure;
     Selector selector = callStructure.callSelector;
     // TODO(23998): Remove this when all information goes through the
     // [SendStructure].
     registry.setSelector(node, selector);
     registry.registerDynamicInvocation(new UniverseSelector(selector, null));
     registry.registerSendStructure(node,
-        new InvokeStructure(new AccessSemantics.expression(), selector));
+        new InvokeStructure(const DynamicAccess.expression(), selector));
     return const NoneResult();
   }
 
   /// Handle a, possibly invalid, assertion, like `assert(cond)` or `assert()`.
   ResolutionResult handleAssert(Send node) {
     assert(invariant(node, node.isCall,
         message: "Unexpected assert: $node"));
     // If this send is of the form "assert(expr);", then
     // this is an assertion.
 
@@ skipping 14 matching lines @@
       sendStructure = const InvalidAssertStructure();
     }
     registry.registerAssert(node);
     registry.registerSendStructure(node, sendStructure);
     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 = new AccessSemantics.thisProperty();
+    AccessSemantics semantics = const DynamicAccess.thisProperty();
     return handleDynamicAccessSemantics(node, name, semantics);
   }
 
   /// Handle access on `this`, like `this()` and `this` when it is parsed as a
   /// [Send] node.
   ResolutionResult handleThisAccess(Send node) {
-    AccessSemantics accessSemantics = new AccessSemantics.thisAccess();
+    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].
       if (checkThisAccess(node)) {
         registry.registerDynamicInvocation(
             new UniverseSelector(selector, null));
         registry.registerSendStructure(node,
@@ skipping 513 matching lines @@
     registry.registerSendStructure(node, sendStructure);
     // TODO(23998): Remove this when all information goes through
     // the [SendStructure].
     registry.setSelector(node, selector);
     return const NoneResult();
   }
 
   /// 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 =
-        new DynamicAccess.dynamicProperty(node.receiver);
+    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;
     visitConditionalPrefix(receiver);
-    AccessSemantics semantics =
-        new DynamicAccess.ifNotNullProperty(receiver);
+    AccessSemantics semantics = const DynamicAccess.ifNotNullProperty();
     return handleDynamicAccessSemantics(node, name, semantics);
   }
 
   /// Handle `this` as a qualified property, like `a.this`.
   ResolutionResult handleQualifiedThisAccess(Send node, Name name) {
     ErroneousElement error = reportAndCreateErroneousElement(
         node.selector,
         name.text,
         MessageKind.THIS_PROPERTY, {},
         isError: true);
@@ skipping 521 matching lines @@
   /// Handle index operations like `a[b] = c`, `a[b] += c`, and `a[b]++`.
   ResolutionResult handleIndexSendSet(SendSet node) {
     String operatorText = node.assignmentOperator.source;
     Node receiver = node.receiver;
     Node index = node.arguments.head;
     visitExpression(receiver);
     visitExpression(index);
     if (node.isPrefix || node.isPostfix) {
       // `a[b]++` or `++a[b]`.
       IncDecOperator operator = IncDecOperator.parse(operatorText);
-      AccessSemantics semantics = new DynamicAccess.dynamicProperty(receiver);
+      AccessSemantics semantics = const DynamicAccess.dynamicProperty();
       Selector getterSelector = new Selector.index();
       Selector setterSelector = new Selector.indexSet();
       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);
@@ skipping 12 matching lines @@
               semantics, operator, getterSelector, setterSelector);
       registry.registerSendStructure(node, sendStructure);
       return const NoneResult();
     } else {
       Node rhs = node.arguments.tail.head;
       visitExpression(rhs);
 
       AssignmentOperator operator = AssignmentOperator.parse(operatorText);
       if (operator.kind == AssignmentOperatorKind.ASSIGN) {
         // `a[b] = c`.
-        AccessSemantics semantics = new DynamicAccess.dynamicProperty(receiver);
+        AccessSemantics semantics = const DynamicAccess.dynamicProperty();
         Selector setterSelector = new Selector.indexSet();
 
         // TODO(23998): Remove this when selectors are only accessed
         // through the send structure.
         registry.setSelector(node, setterSelector);
         registry.registerDynamicInvocation(
             new UniverseSelector(setterSelector, null));
 
         SendStructure sendStructure =
             new IndexSetStructure(semantics, setterSelector);
         registry.registerSendStructure(node, sendStructure);
         return const NoneResult();
       } else {
         // `a[b] += c`.
-        AccessSemantics semantics = new DynamicAccess.dynamicProperty(receiver);
+        AccessSemantics semantics = const DynamicAccess.dynamicProperty();
         Selector getterSelector = new Selector.index();
         Selector setterSelector = new Selector.indexSet();
         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);
@@ skipping 1581 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);
 }