Refactor handling of compounds.

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

 // Copyright (c) 2015, 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 dart2js.semantics_visitor;
 
 enum SendStructureKind {
   GET,
   SET,
   INVOKE,
@@ skipping 10 matching lines @@
   POSTFIX,
   INDEX_PREFIX,
   INDEX_POSTFIX,
 }
 
 abstract class SendResolverMixin {
   TreeElements get elements;
 
   internalError(Spannable spannable, String message);
 
-  AccessSemantics handleStaticallyResolvedAccess(Send node,
-                                                 Element element,
-                                                 Element getter) {
+  AccessSemantics handleCompoundErroneousSetterAccess(
+      Send node,
+      Element setter,
+      Element getter) {
+    assert(invariant(node, Elements.isUnresolved(setter),
+        message: "Unexpected erreneous compound setter: $setter."));
+    if (getter.isStatic) {
+      if (getter.isGetter) {
+        return new CompoundAccessSemantics(
+            CompoundAccessKind.UNRESOLVED_STATIC_SETTER, getter, setter);
+      } else if (getter.isField) {
+        // TODO(johnniwinther): Handle const field separately.
+        assert(invariant(node, getter.isFinal || getter.isConst,
+            message: "Field expected to be final or const."));
+        return new StaticAccess.finalStaticField(getter);
+      } else if (getter.isFunction) {
+        return new StaticAccess.staticMethod(getter);
+      } else {
+        return internalError(node,
+            "Unexpected erroneous static compound: getter=$getter");
+      }
+    } else if (getter.isTopLevel) {
+      if (getter.isGetter) {
+        return new CompoundAccessSemantics(
+            CompoundAccessKind.UNRESOLVED_TOPLEVEL_SETTER, getter, setter);
+      } else if (getter.isField) {
+        // TODO(johnniwinther): Handle const field separately.
+        assert(invariant(node, getter.isFinal || getter.isConst,
+            message: "Field expected to be final or const."));
+        return new StaticAccess.finalTopLevelField(getter);
+      } else if (getter.isFunction) {
+        return new StaticAccess.topLevelMethod(getter);
+      } else {
+        return internalError(node,
+            "Unexpected erroneous top level compound: getter=$getter");
+      }
+    } else if (getter.isParameter) {
+      assert(invariant(node, getter.isFinal,
+          message: "Parameter expected to be final."));
+      return new StaticAccess.finalParameter(getter);
+    } else if (getter.isLocal) {
+      if (getter.isVariable) {
+        // TODO(johnniwinther): Handle const variable separately.
+        assert(invariant(node, getter.isFinal || getter.isConst,
+            message: "Variable expected to be final or const."));
+        return new StaticAccess.finalLocalVariable(getter);
+      } else if (getter.isFunction) {
+        return new StaticAccess.localFunction(getter);
+      } else {
+        return internalError(node,
+            "Unexpected erroneous local compound: getter=$getter");
+      }
+    } else if (getter.isErroneous) {
+      return new StaticAccess.unresolved(getter);
+    } else {
+      return internalError(node,
+          "Unexpected erroneous compound: getter=$getter");
+    }
+  }
+
+  AccessSemantics handleStaticallyResolvedAccess(
+      Send node,
+      Element element,
+      Element getter,
+      {bool isCompound}) {
+    if (element == null) {
+      assert(invariant(node, isCompound, message:
+        "Non-compound static access without element."));
+      assert(invariant(node, getter != null, message:
+        "Compound static access without element."));
+      return handleCompoundErroneousSetterAccess(node, element, getter);
+    }
     if (element.isErroneous) {
+      if (isCompound) {
+        return handleCompoundErroneousSetterAccess(node, element, getter);
+      }
       return new StaticAccess.unresolved(element);
     } else if (element.isParameter) {
       return new StaticAccess.parameter(element);
     } else if (element.isLocal) {
       if (element.isFunction) {
         return new StaticAccess.localFunction(element);
       } else {
         return new StaticAccess.localVariable(element);
       }
     } else if (element.isStatic) {
       if (element.isField) {
+        if (element.isFinal || element.isConst) {
+          // TODO(johnniwinther): Handle const field separately.
+          return new StaticAccess.finalStaticField(element);
+        }
         return new StaticAccess.staticField(element);
       } else if (element.isGetter) {
+        if (isCompound) {
+          return new CompoundAccessSemantics(
+              CompoundAccessKind.UNRESOLVED_STATIC_SETTER, element, null);
+        }
         return new StaticAccess.staticGetter(element);
       } else if (element.isSetter) {
         if (getter != null) {
           CompoundAccessKind accessKind;
-          if (getter.isGetter) {
+          if (getter.isErroneous) {
+            accessKind = CompoundAccessKind.UNRESOLVED_STATIC_GETTER;
+          } else if (getter.isAbstractField) {
+            AbstractFieldElement abstractField = getter;
+            if (abstractField.getter == null) {
+              accessKind = CompoundAccessKind.UNRESOLVED_STATIC_GETTER;
+            } else {
+              // TODO(johnniwinther): This might be dead code.
+              getter = abstractField.getter;
+              accessKind = CompoundAccessKind.STATIC_GETTER_SETTER;
+            }
+          } else if (getter.isGetter) {
             accessKind = CompoundAccessKind.STATIC_GETTER_SETTER;
           } else {
             accessKind = CompoundAccessKind.STATIC_METHOD_SETTER;
           }
           return new CompoundAccessSemantics(
               accessKind, getter, element);
         } else {
           return new StaticAccess.staticSetter(element);
         }
       } else {
         return new StaticAccess.staticMethod(element);
       }
     } else if (element.isTopLevel) {
       if (element.isField) {
+        if (element.isFinal || element.isConst) {
+          // TODO(johnniwinther): Handle const field separately.
+          return new StaticAccess.finalTopLevelField(element);
+        }
         return new StaticAccess.topLevelField(element);
       } else if (element.isGetter) {
         return new StaticAccess.topLevelGetter(element);
       } else if (element.isSetter) {
         if (getter != null) {
           CompoundAccessKind accessKind;
-          if (getter.isGetter) {
+          if (getter.isErroneous) {
+            accessKind = CompoundAccessKind.UNRESOLVED_TOPLEVEL_GETTER;
+          } else if (getter.isAbstractField) {
+            AbstractFieldElement abstractField = getter;
+            if (abstractField.getter == null) {
+              accessKind = CompoundAccessKind.UNRESOLVED_TOPLEVEL_GETTER;
+            } else {
+              // TODO(johnniwinther): This might be dead code.
+              getter = abstractField.getter;
+              accessKind = CompoundAccessKind.TOPLEVEL_GETTER_SETTER;
+            }
+          } else if (getter.isGetter) {
             accessKind = CompoundAccessKind.TOPLEVEL_GETTER_SETTER;
           } else {
             accessKind = CompoundAccessKind.TOPLEVEL_METHOD_SETTER;
           }
           return new CompoundAccessSemantics(
               accessKind, getter, element);
         } else {
           return new StaticAccess.topLevelSetter(element);
         }
       } else {
@@ skipping 124 matching lines @@
               kind = SendStructureKind.BINARY;
               break;
           }
         } else {
           return const InvalidBinaryStructure();
         }
       }
     }
     AccessSemantics semantics = computeAccessSemantics(
         node,
-        isGetOrSet: kind == SendStructureKind.GET ||
-                    kind == SendStructureKind.SET,
+        isSet: kind == SendStructureKind.SET,
         isInvoke: kind == SendStructureKind.INVOKE,
         isCompound: kind == SendStructureKind.COMPOUND ||
                     kind == SendStructureKind.COMPOUND_INDEX_SET ||
                     kind == SendStructureKind.PREFIX ||
                     kind == SendStructureKind.POSTFIX ||
                     kind == SendStructureKind.INDEX_PREFIX ||
                     kind == SendStructureKind.INDEX_POSTFIX);
     if (semantics == null) {
       return internalError(node, 'No semantics for $node');
     }
@@ skipping 77 matching lines @@
             elements.getGetterSelectorInComplexSendSet(node);
         return new PostfixStructure(
             semantics,
             incDecOperator,
             getterSelector,
             selector);
     }
   }
 
   AccessSemantics computeAccessSemantics(Send node,
-                                         {bool isGetOrSet: false,
+                                         {bool isSet: false,
                                           bool isInvoke: false,
                                           bool isCompound: false}) {
     Element element = elements[node];
     Element getter = isCompound ? elements[node.selector] : null;
     if (elements.isTypeLiteral(node)) {
       DartType dartType = elements.getTypeLiteralType(node);
       // TODO(johnniwinther): Handle deferred constants. There are runtime
       // but not compile-time constants and should have their own
       // [DeferredConstantExpression] class.
       ConstantExpression constant = elements.getConstant(
-          isInvoke ? node.selector : node);
+          isInvoke || isSet || isCompound ? node.selector : node);
       switch (dartType.kind) {
         case TypeKind.INTERFACE:
           return new ConstantAccess.classTypeLiteral(constant);
         case TypeKind.TYPEDEF:
           return new ConstantAccess.typedefTypeLiteral(constant);
         case TypeKind.TYPE_VARIABLE:
           return new StaticAccess.typeParameterTypeLiteral(dartType.element);
         case TypeKind.DYNAMIC:
           return new ConstantAccess.dynamicTypeLiteral(constant);
         default:
           return internalError(node, "Unexpected type literal type: $dartType");
       }
     } else if (node.isSuperCall) {
       if (Elements.isUnresolved(element)) {
         if (isCompound) {
           if (Elements.isUnresolved(getter)) {
             // TODO(johnniwinther): Ensure that [getter] is not null. This
             // happens in the case of missing super getter.
-            return new CompoundAccessSemantics(
-                CompoundAccessKind.UNRESOLVED_SUPER_GETTER, getter, element);
+            return new StaticAccess.unresolvedSuper(element);
+          } else if (getter.isField) {
+            assert(invariant(node, getter.isFinal,
+                message: "Super field expected to be final."));
+            return new StaticAccess.superFinalField(getter);
+          } else if (getter.isFunction) {
+            if (node.isIndex) {
+              return new CompoundAccessSemantics(
+                  CompoundAccessKind.UNRESOLVED_SUPER_SETTER, getter, element);
+            } else {
+              return new StaticAccess.superMethod(getter);
+            }
           } else {
             return new CompoundAccessSemantics(
                 CompoundAccessKind.UNRESOLVED_SUPER_SETTER, getter, element);
           }
         } else {
           return new StaticAccess.unresolvedSuper(element);
         }
       } else if (isCompound && Elements.isUnresolved(getter)) {
         // TODO(johnniwinther): Ensure that [getter] is not null. This happens
         // in the case of missing super getter.
         return new CompoundAccessSemantics(
             CompoundAccessKind.UNRESOLVED_SUPER_GETTER, getter, element);
       } else if (element.isField) {
         if (getter != null && getter != element) {
           CompoundAccessKind accessKind;
           if (getter.isField) {
             accessKind = CompoundAccessKind.SUPER_FIELD_FIELD;
           } else if (getter.isGetter) {
             accessKind = CompoundAccessKind.SUPER_GETTER_FIELD;
           } else {
             return internalError(node,
                "Unsupported super call: $node : $element/$getter.");
           }
           return new CompoundAccessSemantics(accessKind, getter, element);
+        } else if (element.isFinal) {
+          return new StaticAccess.superFinalField(element);
         }
         return new StaticAccess.superField(element);
       } else if (element.isGetter) {
         return new StaticAccess.superGetter(element);
       } else if (element.isSetter) {
         if (getter != null) {
           CompoundAccessKind accessKind;
           if (getter.isField) {
             accessKind = CompoundAccessKind.SUPER_FIELD_SETTER;
           } else if (getter.isGetter) {
@@ skipping 15 matching lines @@
     } else if (Elements.isClosureSend(node, element)) {
       if (element == null) {
         if (node.selector.isThis()) {
           return new AccessSemantics.thisAccess();
         } else {
           return new AccessSemantics.expression();
         }
       } else if (Elements.isErroneous(element)) {
         return new StaticAccess.unresolved(element);
       } else {
-        return handleStaticallyResolvedAccess(node, element, getter);
+        return handleStaticallyResolvedAccess(
+            node, element, getter, isCompound: isCompound);
       }
     } else {
-      if (Elements.isErroneous(element)) {
-        return new StaticAccess.unresolved(element);
-      } else if (isCompound && Elements.isErroneous(getter)) {
-        return new StaticAccess.unresolved(getter);
-      } else if (element == null || element.isInstanceMember) {
+      bool isDynamicAccess(Element e) => e == null || e.isInstanceMember;
+
+      if (isDynamicAccess(element) &&
+           (!isCompound || isDynamicAccess(getter))) {
         if (node.receiver == null || node.receiver.isThis()) {
           return new AccessSemantics.thisProperty();
         } else {
           return new DynamicAccess.dynamicProperty(node.receiver);
         }
-      } else if (element.impliesType) {
+      } else if (element != null && element.impliesType) {
         // TODO(johnniwinther): Provide an [ErroneousElement].
         // This happens for code like `C.this`.
         return new StaticAccess.unresolved(null);
       } else {
-        return handleStaticallyResolvedAccess(node, element, getter);
+        return handleStaticallyResolvedAccess(
+            node, element, getter, isCompound: isCompound);
       }
     }
   }
 
   ConstructorAccessSemantics computeConstructorAccessSemantics(
         ConstructorElement constructor,
         DartType type,
         {bool mustBeConstant: false}) {
     if (mustBeConstant && !constructor.isConst) {
       return new ConstructorAccessSemantics(
@@ skipping 376 matching lines @@
       return internalError(node, "Unexpected variable $element.");
     }
     if (element.isConst) {
       ConstantExpression constant = elements.getConstant(element.initializer);
       return new ConstantVariableStructure(kind, node, element, constant);
     } else {
       return new NonConstantVariableStructure(kind, node, element);
     }
   }
 }