Introduce ClassLike, MemberLike, FieldLike and FunctionLike

pkg/compiler/lib/src/ssa/codegen.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.
 
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
@@ skipping 1564 matching lines @@
           .withSourceInformation(node.sourceInformation));
       registry.registerUseInterceptor();
     }
   }
 
   visitInvokeDynamicMethod(HInvokeDynamicMethod node) {
     use(node.receiver);
     js.Expression object = pop();
     String methodName;
     List<js.Expression> arguments = visitArguments(node.inputs);
-    Element target = node.element;
+    MemberElement target = node.element;
 
     // TODO(herhut): The namer should return the appropriate backendname here.
     if (target != null && !node.isInterceptedCall) {
       if (target == helpers.jsArrayAdd) {
         methodName = 'push';
       } else if (target == helpers.jsArrayRemoveLast) {
         methodName = 'pop';
       } else if (target == helpers.jsStringSplit) {
         methodName = 'split';
         // Split returns a List, so we make sure the backend knows the
@@ skipping 77 matching lines @@
     // might hit a `noSuchMethod`, we register an untyped selector.
     return compiler.closedWorld.extendMaskIfReachesAll(selector, mask);
   }
 
   void registerMethodInvoke(HInvokeDynamic node) {
     Selector selector = node.selector;
 
     // If we don't know what we're calling or if we are calling a getter,
     // we need to register that fact that we may be calling a closure
     // with the same arguments.
-    Element target = node.element;
+    MemberElement target = node.element;
     if (target == null || target.isGetter) {
       // TODO(kasperl): If we have a typed selector for the call, we
       // may know something about the types of closures that need
       // the specific closure call method.
       Selector call = new Selector.callClosureFrom(selector);
       registry.registerDynamicUse(new DynamicUse(call, null));
     }
     if (target != null) {
       // This is a dynamic invocation which we have found to have a single
       // target but for some reason haven't inlined. We are _still_ accessing
@@ skipping 61 matching lines @@
     Selector call = new Selector.callClosureFrom(node.selector);
     use(node.receiver);
     push(js
         .propertyCall(pop(), backend.namer.invocationName(call),
             visitArguments(node.inputs))
         .withSourceInformation(node.sourceInformation));
     registry.registerDynamicUse(new DynamicUse(call, null));
   }
 
   visitInvokeStatic(HInvokeStatic node) {
-    Element element = node.element;
+    MemberElement element = node.element;
     List<DartType> instantiatedTypes = node.instantiatedTypes;
 
     if (instantiatedTypes != null && !instantiatedTypes.isEmpty) {
       instantiatedTypes.forEach((type) {
         registry.registerInstantiation(type);
       });
     }
 
     List<js.Expression> arguments = visitArguments(node.inputs, start: 0);
 
@@ skipping 26 matching lines @@
       registry.registerStaticUse(element.isConstructor
           ? new StaticUse.constructorInvoke(element, callStructure)
           : new StaticUse.staticInvoke(element, callStructure));
       push(backend.emitter.staticFunctionAccess(element));
       push(new js.Call(pop(), arguments,
           sourceInformation: node.sourceInformation));
     }
   }
 
   visitInvokeSuper(HInvokeSuper node) {
-    Element superElement = node.element;
+    MemberElement superElement = node.element;
     ClassElement superClass = superElement.enclosingClass;
     if (superElement.isField) {
       js.Name fieldName = backend.namer.instanceFieldPropertyName(superElement);
       use(node.inputs[0]);
       js.PropertyAccess access = new js.PropertyAccess(pop(), fieldName)
           .withSourceInformation(node.sourceInformation);
       if (node.isSetter) {
         registry.registerStaticUse(superElement.isSetter
             ? new StaticUse.superSetterSet(superElement)
             : new StaticUse.superFieldSet(superElement));
@@ skipping 37 matching lines @@
           backend.namer.aliasedSuperMemberPropertyName(superElement),
           visitArguments(node.inputs, start: 1)
         ]) // Skip receiver argument.
             .withSourceInformation(node.sourceInformation));
       }
     }
   }
 
   visitFieldGet(HFieldGet node) {
     use(node.receiver);
-    Element element = node.element;
+    MemberElement element = node.element;
     if (node.isNullCheck) {
       // We access a JavaScript member we know all objects besides
       // null and undefined have: V8 does not like accessing a member
       // that does not exist.
       push(new js.PropertyAccess.field(pop(), 'toString')
           .withSourceInformation(node.sourceInformation));
     } else if (element == helpers.jsIndexableLength) {
       // We're accessing a native JavaScript property called 'length'
       // on a JS String or a JS array. Therefore, the name of that
       // property should not be mangled.
       push(new js.PropertyAccess.field(pop(), 'length')
           .withSourceInformation(node.sourceInformation));
     } else {
       js.Name name = backend.namer.instanceFieldPropertyName(element);
       push(new js.PropertyAccess(pop(), name)
           .withSourceInformation(node.sourceInformation));
       registry.registerStaticUse(new StaticUse.fieldGet(element));
     }
   }
 
   visitFieldSet(HFieldSet node) {
-    Element element = node.element;
+    MemberElement element = node.element;
     registry.registerStaticUse(new StaticUse.fieldSet(element));
     js.Name name = backend.namer.instanceFieldPropertyName(element);
     use(node.receiver);
     js.Expression receiver = pop();
     use(node.value);
     push(new js.Assignment(new js.PropertyAccess(receiver, name), pop())
         .withSourceInformation(node.sourceInformation));
   }
 
   visitReadModifyWrite(HReadModifyWrite node) {
-    Element element = node.element;
+    FieldElement element = node.element;
     registry.registerStaticUse(new StaticUse.fieldGet(element));
     registry.registerStaticUse(new StaticUse.fieldSet(element));
     js.Name name = backend.namer.instanceFieldPropertyName(element);
     use(node.receiver);
     js.Expression fieldReference = new js.PropertyAccess(pop(), name);
     if (node.isPreOp) {
       push(new js.Prefix(node.jsOp, fieldReference)
           .withSourceInformation(node.sourceInformation));
     } else if (node.isPostOp) {
       push(new js.Postfix(node.jsOp, fieldReference)
@@ skipping 358 matching lines @@
     js.Call value = new js.Call(jsHelper, [pop()])
         .withSourceInformation(node.sourceInformation);
     push(value);
   }
 
   void visitSwitch(HSwitch node) {
     // Switches are handled using [visitSwitchInfo].
   }
 
   void visitStatic(HStatic node) {
-    Element element = node.element;
+    MemberLike element = node.element;
     assert(element.isFunction || element.isField);
     if (element.isFunction) {
       push(backend.emitter
           .isolateStaticClosureAccess(element)
           .withSourceInformation(node.sourceInformation));
       registry.registerStaticUse(new StaticUse.staticTearOff(element));
     } else {
       push(backend.emitter
           .staticFieldAccess(element)
           .withSourceInformation(node.sourceInformation));
       registry.registerStaticUse(new StaticUse.staticGet(element));
     }
   }
 
   void visitLazyStatic(HLazyStatic node) {
-    Element element = node.element;
+    FieldLike element = node.element;
     registry.registerStaticUse(new StaticUse.staticInit(element));
     js.Expression lazyGetter =
         backend.emitter.isolateLazyInitializerAccess(element);
     js.Call call = new js.Call(lazyGetter, <js.Expression>[],
         sourceInformation: node.sourceInformation);
     push(call);
   }
 
   void visitStaticStore(HStaticStore node) {
     registry.registerStaticUse(new StaticUse.staticSet(node.element));
@@ skipping 719 matching lines @@
     registry.registerStaticUse(new StaticUse.staticInvoke(
         helper, new CallStructure.unnamed(argumentCount)));
     return backend.emitter.staticFunctionAccess(helper);
   }
 
   @override
   void visitRef(HRef node) {
     visit(node.value);
   }
 }