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

runtime/vm/parser.cc

 // 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.
 
 #include "vm/parser.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 6418 matching lines @@
 // Calling VM-internal helpers, uses implementation core library.
 AstNode* Parser::MakeStaticCall(const String& cls_name,
                                 const String& func_name,
                                 ArgumentListNode* arguments) {
   const Class& cls = Class::Handle(Library::LookupCoreClass(cls_name));
   ASSERT(!cls.IsNull());
   const Function& func = Function::ZoneHandle(
       Resolver::ResolveStatic(cls,
                               func_name,
                               arguments->length(),
-                              arguments->names(),
-                              Resolver::kIsQualified));
+                              arguments->names()));
   ASSERT(!func.IsNull());
   return new StaticCallNode(arguments->token_pos(), func, arguments);
 }
 
 
 AstNode* Parser::MakeAssertCall(intptr_t begin, intptr_t end) {
   ArgumentListNode* arguments = new ArgumentListNode(begin);
   arguments->Add(new LiteralNode(begin,
       Integer::ZoneHandle(Integer::New(begin))));
   arguments->Add(new LiteralNode(end,
@@ skipping 1501 matching lines @@
                                  intptr_t ident_pos) {
   TRACE_PARSER("ParseStaticCall");
   const intptr_t call_pos = TokenPos();
   ASSERT(CurrentToken() == Token::kLPAREN);
   ArgumentListNode* arguments = ParseActualParameters(NULL, kAllowConst);
   const int num_arguments = arguments->length();
   const Function& func = Function::ZoneHandle(
       Resolver::ResolveStatic(cls,
                               func_name,
                               num_arguments,
-                              arguments->names(),
-                              Resolver::kIsQualified));
+                              arguments->names()));
   if (func.IsNull()) {
     // Check if there is a static field of the same name, it could be a closure
     // and so we try and invoke the closure.
     AstNode* closure = NULL;
     const Field& field = Field::ZoneHandle(cls.LookupStaticField(func_name));
     Function& func = Function::ZoneHandle();
     if (field.IsNull()) {
       // No field, check if we have an explicit getter function.
       const String& getter_name =
           String::ZoneHandle(Field::GetterName(func_name));
       const int kNumArguments = 0;  // no arguments.
       func = Resolver::ResolveStatic(cls,
                                      getter_name,
                                      kNumArguments,
-                                     Object::empty_array(),
-                                     Resolver::kIsQualified);
+                                     Object::empty_array());
       if (!func.IsNull()) {
         ASSERT(func.kind() != RawFunction::kImplicitStaticFinalGetter);
         EnsureSavedCurrentContext();
         closure = new StaticGetterNode(call_pos,
                                        NULL,
                                        false,
                                        Class::ZoneHandle(cls.raw()),
                                        func_name);
         return new ClosureCallNode(call_pos, closure, arguments);
       }
@@ skipping 87 matching lines @@
   const Field& field = Field::ZoneHandle(cls.LookupStaticField(field_name));
   Function& func = Function::ZoneHandle();
   if (field.IsNull()) {
     // No field, check if we have an explicit getter function.
     const String& getter_name =
         String::ZoneHandle(Field::GetterName(field_name));
     const int kNumArguments = 0;  // no arguments.
     func = Resolver::ResolveStatic(cls,
                                    getter_name,
                                    kNumArguments,
-                                   Object::empty_array(),
-                                   Resolver::kIsQualified);
+                                   Object::empty_array());
     if (func.IsNull()) {
       // We might be referring to an implicit closure, check to see if
       // there is a function of the same name.
       func = cls.LookupStaticFunction(field_name);
       if (!func.IsNull()) {
         access = CreateImplicitClosureNode(func, call_pos, NULL);
       } else {
         // No function to closurize found found.
         // This field access may turn out to be a call to the setter.
         // Create a getter call, which may later be turned into
@@ skipping 549 matching lines @@
     // This field has not been referenced yet and thus the value has
     // not been evaluated. If the field is const, call the static getter method
     // to evaluate the expression and canonicalize the value.
     if (field.is_const()) {
       field.set_value(Object::transition_sentinel());
       const int kNumArguments = 0;  // no arguments.
       const Function& func =
           Function::Handle(Resolver::ResolveStatic(field_owner,
                                                    getter_name,
                                                    kNumArguments,
-                                                   Object::empty_array(),
-                                                   Resolver::kIsQualified));
+                                                   Object::empty_array()));
       ASSERT(!func.IsNull());
       ASSERT(func.kind() == RawFunction::kImplicitStaticFinalGetter);
       Object& const_value = Object::Handle(
           DartEntry::InvokeFunction(func, Object::empty_array()));
       if (const_value.IsError()) {
         const Error& error = Error::Cast(const_value);
         if (error.IsUnhandledException()) {
           // An exception may not occur in every parse attempt, i.e., the
           // generated AST is not deterministic. Therefore mark the function as
           // not optimizable.
@@ skipping 1918 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart