Refactoring resolution of local access and unqualified access of statics

pkg/compiler/lib/src/ssa/builder.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 ssa;
 
 class SsaFunctionCompiler implements FunctionCompiler {
   SsaCodeGeneratorTask generator;
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
@@ skipping 1304 matching lines @@
 
     // Bail out early if the inlining decision is in the cache and we can't
     // inline (no need to check the hard constraints).
     bool cachedCanBeInlined =
         backend.inlineCache.canInline(function, insideLoop: insideLoop);
     if (cachedCanBeInlined == false) return false;
 
     bool meetsHardConstraints() {
       if (compiler.disableInlining) return false;
 
-      assert(selector != null
-             || Elements.isStaticOrTopLevel(element)
-             || element.isGenerativeConstructorBody);
+      assert(invariant(
+          currentNode != null ? currentNode : element,
+          selector != null ||
+          Elements.isStaticOrTopLevel(element) ||
+          element.isGenerativeConstructorBody,
+          message: "Missing selector for inlining of $element."));
       if (selector != null && !selector.applies(function, compiler.world)) {
         return false;
       }
 
       // Don't inline operator== methods if the parameter can be null.
       if (element.name == '==') {
         if (element.enclosingClass != compiler.objectClass
             && providedArguments[1].canBeNull()) {
           return false;
         }
@@ skipping 1901 matching lines @@
 
   HInstruction generateInstanceSendReceiver(ast.Send send) {
     assert(Elements.isInstanceSend(send, elements));
     if (send.receiver == null) {
       return localsHandler.readThis();
     }
     visit(send.receiver);
     return pop();
   }
 
-  String noSuchMethodTargetSymbolString(ErroneousElement error,
-                                        [String prefix]) {
+  String noSuchMethodTargetSymbolString(Element error, [String prefix]) {
     String result = error.name;
     if (prefix == "set") return "$result=";
     return result;
   }
 
   /**
    * Returns a set of interceptor classes that contain the given
    * [selector].
    */
   void generateInstanceGetterWithCompiledReceiver(ast.Send send,
@@ skipping 20 matching lines @@
   }
 
   /// Inserts a call to checkDeferredIsLoaded if the send has a prefix that
   /// resolves to a deferred library.
   void generateIsDeferredLoadedCheckOfSend(ast.Send node) {
     generateIsDeferredLoadedCheckIfNeeded(
         compiler.deferredLoadTask.deferredPrefixElement(node, elements),
         node);
   }
 
+  void handleInvalidStaticGet(ast.Send node, Element element) {
+    generateThrowNoSuchMethod(
+        node,
+        noSuchMethodTargetSymbolString(element, 'get'),
+        argumentNodes: const Link<ast.Node>());
+  }
+
   /// Generate read access of an unresolved static or top level entity.
   void generateStaticUnresolvedGet(ast.Send node, Element element) {
     if (element is ErroneousElement) {
       // An erroneous element indicates an unresolved static getter.
-      generateThrowNoSuchMethod(
-          node,
-          noSuchMethodTargetSymbolString(element, 'get'),
-          argumentNodes: const Link<ast.Node>());
+      handleInvalidStaticGet(node, element);
     } else {
       // This happens when [element] has parse errors.
       assert(invariant(node, element == null || element.isErroneous));
       // TODO(ahe): Do something like the above, that is, emit a runtime
       // error.
       stack.add(graph.addConstantNull(compiler));
     }
   }
 
   /// Read a static or top level [field] of constant value.
@@ skipping 591 matching lines @@
   @override
   visitLocalFunctionInvoke(
       ast.Send node,
       LocalFunctionElement function,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     generateCallInvoke(node, localsHandler.readLocal(function));
   }
 
+  @override
+  visitLocalFunctionIncompatibleInvoke(
+      ast.Send node,
+      LocalFunctionElement function,
+      ast.NodeList arguments,
+      CallStructure callStructure,
+      _) {
+    generateCallInvoke(node, localsHandler.readLocal(function));
+  }
+
   void handleForeignJs(ast.Send node) {
     Link<ast.Node> link = node.arguments;
     // Don't visit the first argument, which is the type, and the second
     // argument, which is the foreign code.
     if (link.isEmpty || link.tail.isEmpty) {
       compiler.internalError(node.argumentsNode,
           'At least two arguments expected.');
     }
     native.NativeBehavior nativeBehavior =
         compiler.enqueuer.resolution.nativeEnqueuer.getNativeBehaviorOf(node);
@@ skipping 1220 matching lines @@
       ast.Send node,
       FunctionElement getter,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     generateStaticGetterGet(node, getter);
     generateCallInvoke(node, pop());
   }
 
   @override
+  void visitTopLevelSetterGet(
+      ast.Send node,
+      MethodElement setter,
+      _) {
+    handleInvalidStaticGet(node, setter);
+  }
+
+  @override
+  void visitStaticSetterGet(
+      ast.Send node,
+      MethodElement setter,
+      _) {
+    handleInvalidStaticGet(node, setter);
+  }
+
+  @override
   void visitUnresolvedGet(
       ast.Send node,
       Element element,
       _) {
     generateStaticUnresolvedGet(node, element);
   }
 
+  void handleInvalidStaticInvoke(ast.Send node, Element element) {
+    generateThrowNoSuchMethod(node,
+                              noSuchMethodTargetSymbolString(element),
+                              argumentNodes: node.arguments);
+  }
+
+  @override
+  void visitStaticSetterInvoke(
+      ast.Send node,
+      MethodElement setter,
+      ast.NodeList arguments,
+      CallStructure callStructure,
+      _) {
+    handleInvalidStaticInvoke(node, setter);
+  }
+
+  @override
+  void visitTopLevelSetterInvoke(
+      ast.Send node,
+      MethodElement setter,
+      ast.NodeList arguments,
+      CallStructure callStructure,
+      _) {
+    handleInvalidStaticInvoke(node, setter);
+  }
+
   @override
   void visitUnresolvedInvoke(
       ast.Send node,
       Element element,
       ast.NodeList arguments,
       Selector selector,
       _) {
     if (element is ErroneousElement) {
       // An erroneous element indicates that the funciton could not be
       // resolved (a warning has been issued).
-      generateThrowNoSuchMethod(node,
-                                noSuchMethodTargetSymbolString(element),
-                                argumentNodes: node.arguments);
+      handleInvalidStaticInvoke(node, element);
     } else {
       // TODO(ahe): Do something like [generateWrongArgumentCountError].
       stack.add(graph.addConstantNull(compiler));
     }
     return;
   }
 
   HConstant addConstantString(String string) {
     ast.DartString dartString = new ast.DartString.literal(string);
     ConstantValue constant = constantSystem.createString(dartString);
@@ skipping 2647 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
   }
 }