Refactoring resolution of local access and unqualified access of statics

pkg/compiler/lib/src/inferrer/simple_types_inferrer.dart

 // Copyright (c) 2013, 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.
 
 library simple_types_inferrer;
 
 import '../closure.dart' show ClosureClassMap, ClosureScope;
 import '../constants/values.dart' show ConstantValue, IntConstantValue;
 import '../cps_ir/cps_ir_nodes.dart' as cps_ir show Node;
 import '../dart_types.dart'
@@ skipping 1678 matching lines @@
   T visitTopLevelGetterInvoke(
       ast.Send node,
       FunctionElement getter,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     return handleStaticFieldOrGetterInvoke(node, getter);
   }
 
   @override
+  T visitStaticSetterInvoke(
+      ast.Send node,
+      MethodElement setter,
+      ast.NodeList arguments,
+      CallStructure callStructure,
+      _) {
+    return handleInvalidStaticInvoke(node);
+  }
+
+  @override
+  T visitTopLevelSetterInvoke(
+      ast.Send node,
+      MethodElement setter,
+      ast.NodeList arguments,
+      CallStructure callStructure,
+      _) {
+    return handleInvalidStaticInvoke(node);
+  }
+
+  @override
   T visitUnresolvedInvoke(
       ast.Send node,
       Element element,
       ast.NodeList arguments,
       Selector selector,
       _) {
     return handleInvalidStaticInvoke(node);
   }
 
   T handleForeignSend(ast.Send node, Element element) {
@@ skipping 155 matching lines @@
 
   @override
   T visitTopLevelGetterGet(
       ast.Send node,
       FunctionElement getter,
       _) {
     return handleStaticGetterGet(node, getter);
   }
 
   @override
+  T visitStaticSetterGet(
+      ast.Send node,
+      MethodElement setter,
+      _) {
+    return types.dynamicType;
+  }
+
+  @override
+  T visitTopLevelSetterGet(
+      ast.Send node,
+      MethodElement setter,
+      _) {
+    return types.dynamicType;
+  }
+
+  @override
   T visitUnresolvedGet(
       ast.Send node,
       Element element,
       _) {
     return types.dynamicType;
   }
 
   /// Handle .call invocation on [closure].
   T handleCallInvoke(ast.Send node, T closure) {
     ArgumentsTypes arguments = analyzeArguments(node.arguments);
@@ skipping 44 matching lines @@
 
   @override
   T visitLocalFunctionInvoke(
       ast.Send node,
       LocalFunctionElement function,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     ArgumentsTypes argumentTypes = analyzeArguments(node.arguments);
     Selector selector = elements.getSelector(node);
-    if (!selector.applies(function, compiler.world)) return types.dynamicType;
     // This only works for function statements. We need a
     // more sophisticated type system with function types to support
     // more.
     return inferrer.registerCalledElement(
         node, selector, outermostElement, function, argumentTypes,
         sideEffects, inLoop);
   }
 
+  @override
+  T visitLocalFunctionIncompatibleInvoke(
+      ast.Send node,
+      LocalFunctionElement function,
+      ast.NodeList arguments,
+      CallStructure callStructure,
+      _) {
+    analyzeArguments(node.arguments);
+    return types.dynamicType;
+  }
+
   T handleStaticSend(ast.Node node,
                      Selector selector,
                      Element element,
                      ArgumentsTypes arguments) {
     assert(!element.isFactoryConstructor ||
            !(element as ConstructorElement).isRedirectingFactory);
     // Erroneous elements may be unresolved, for example missing getters.
     if (Elements.isUnresolved(element)) return types.dynamicType;
     // TODO(herhut): should we follow redirecting constructors here? We would
     // need to pay attention if the constructor is pointing to an erroneous
@@ skipping 202 matching lines @@
     Selector currentSelector = elements.getCurrentSelector(node);
     Selector moveNextSelector = elements.getMoveNextSelector(node);
 
     T iteratorType = handleDynamicSend(node, iteratorSelector, expressionType,
                                        new ArgumentsTypes<T>.empty());
 
     return handleForInLoop(node, iteratorType, currentSelector,
                            moveNextSelector);
   }
 }