Cleanup StaticResolveType, it does not seem to be used anywhere.

runtime/vm/resolver.cc

 // Copyright (c) 2011, 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.
 
 #include "vm/resolver.h"
 
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
@@ skipping 126 matching lines @@
     cls = cls.SuperClass();
   }
   return function.raw();
 }
 
 
 RawFunction* Resolver::ResolveStatic(const Library& library,
                                      const String& class_name,
                                      const String& function_name,
                                      intptr_t num_arguments,
-                                     const Array& argument_names,
-                                     StaticResolveType resolve_type) {
+                                     const Array& argument_names) {
   ASSERT(!library.IsNull());
   Function& function = Function::Handle();
   if (class_name.IsNull() || (class_name.Length() == 0)) {
     // Check if we are referring to a top level function.
     const Object& object = Object::Handle(library.LookupObject(function_name));
     if (!object.IsNull() && object.IsFunction()) {
       function ^= object.raw();
       if (!function.AreValidArguments(num_arguments, argument_names, NULL)) {
         if (FLAG_trace_resolving) {
           String& error_message = String::Handle();
@@ skipping 15 matching lines @@
     }
   } else {
     // Lookup class_name in the library's class dictionary to get at
     // the dart class object. If class_name is not found in the dictionary
     // ResolveStatic will return a NULL function object.
     const Class& cls = Class::Handle(library.LookupClass(class_name));
     if (!cls.IsNull()) {
       function = ResolveStatic(cls,
                                function_name,
                                num_arguments,
-                               argument_names,
-                               resolve_type);
+                               argument_names);
     }
     if (FLAG_trace_resolving && function.IsNull()) {
       OS::Print("ResolveStatic error: function '%s.%s' not found.\n",
                 class_name.ToCString(),
                 function_name.ToCString());
     }
   }
   return function.raw();
 }
 
 
-RawFunction* Resolver::ResolveStaticByName(const Class&  cls,
-                                           const String& function_name,
-                                           StaticResolveType resolve_type) {
-  ASSERT(!cls.IsNull());
-
-  if (FLAG_trace_resolving) {
-    OS::Print("ResolveStatic '%s'\n", function_name.ToCString());
-  }
-
-  // Now look for a static function whose name matches function_name
-  // in the class.
-  Function& function =
-      Function::Handle(cls.LookupStaticFunction(function_name));
-  if (resolve_type == kNotQualified) {
-    // Walk the hierarchy.
-    Class& super_class = Class::Handle(cls.SuperClass());
-    while (function.IsNull()) {
-      function = super_class.LookupStaticFunction(function_name);
-      super_class = super_class.SuperClass();
-      if (super_class.IsNull()) break;
-    }
-  }
-  return function.raw();
-}
-
-
-
 RawFunction* Resolver::ResolveStatic(const Class&  cls,
                                      const String& function_name,
                                      intptr_t num_arguments,
-                                     const Array& argument_names,
-                                     StaticResolveType resolve_type) {
+                                     const Array& argument_names) {
   ASSERT(!cls.IsNull());
-  const Function& function = Function::Handle(
-      ResolveStaticByName(cls, function_name, resolve_type));
+  if (FLAG_trace_resolving) {
+    OS::Print("ResolveStatic '%s'\n", function_name.ToCString());
+  }
+  const Function& function =
+      Function::Handle(cls.LookupStaticFunction(function_name));
   if (function.IsNull() ||
       !function.AreValidArguments(num_arguments, argument_names, NULL)) {
     // Return a null function to signal to the upper levels to throw a
     // resolution error or maybe throw the error right here.
     if (FLAG_trace_resolving) {
       String& error_message = String::Handle(String::New("function not found"));
       if (!function.IsNull()) {
         // Obtain more detailed error message.
         function.AreValidArguments(num_arguments,
                                    argument_names,
                                    &error_message);
       }
       OS::Print("ResolveStatic error '%s': %s.\n",
                 function_name.ToCString(),
                 error_message.ToCString());
     }
     return Function::null();
   }
   return function.raw();
 }
 
 }  // namespace dart