Remove support for interfaces.

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 "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 516 matching lines @@
 
 
 class ClassDesc : public ValueObject {
  public:
   ClassDesc(const Class& cls,
             const String& cls_name,
             bool is_interface,
             intptr_t token_pos)
       : clazz_(cls),
         class_name_(cls_name),
-        is_interface_(is_interface),
         token_pos_(token_pos),
         functions_(GrowableObjectArray::Handle(GrowableObjectArray::New())),
         fields_(GrowableObjectArray::Handle(GrowableObjectArray::New())) {
   }
 
   // Parameter 'name' is the unmangled name, i.e. without the setter
   // name mangling.
   bool FunctionNameExists(const String& name, RawFunction::Kind kind) const {
     // First check if a function or field of same name exists.
     if ((kind != RawFunction::kSetterFunction) && FunctionExists(name)) {
@@ skipping 70 matching lines @@
   }
 
   RawClass* clazz() const {
     return clazz_.raw();
   }
 
   const String& class_name() const {
     return class_name_;
   }
 
-  bool is_interface() const {
-    return is_interface_;
-  }
-
   bool has_constructor() const {
     Function& func = Function::Handle();
     for (int i = 0; i < functions_.Length(); i++) {
       func ^= functions_.At(i);
       if (func.kind() == RawFunction::kConstructor) {
         return true;
       }
     }
     return false;
   }
@@ skipping 49 matching lines @@
     }
     return NULL;
   }
 
   bool FunctionExists(const String& name) const {
     return LookupFunction(name) != NULL;
   }
 
   const Class& clazz_;
   const String& class_name_;
-  const bool is_interface_;
   intptr_t token_pos_;   // Token index of "class" keyword.
   GrowableObjectArray& functions_;
   GrowableObjectArray& fields_;
   GrowableArray<MemberDesc> members_;
 };
 
 
 struct TopLevel {
   TopLevel() :
       fields(GrowableObjectArray::Handle(GrowableObjectArray::New())),
@@ skipping 567 matching lines @@
   if (CurrentToken() != Token::kSTRING) {
     ErrorMsg("string literal expected");
   }
   String& native_name = *CurrentLiteral();
   ConsumeToken();
   ExpectSemicolon();
   return native_name;
 }
 
 
-void Parser::CheckFunctionIsCallable(intptr_t token_pos,
-                                     const Function& function) {
-  if (Class::Handle(function.Owner()).is_interface()) {
-    ErrorMsg(token_pos, "cannot call function of interface '%s'",
-        function.ToFullyQualifiedCString());
-  }
-}
-
-
 // Resolve and return the dynamic function of the given name in the superclass.
 // If it is not found, and resolve_getter is true, try to resolve a getter of
 // the same name. If it is still not found, return noSuchMethod and
 // set is_no_such_method to true..
 RawFunction* Parser::GetSuperFunction(intptr_t token_pos,
                                       const String& name,
                                       bool resolve_getter,
                                       bool* is_no_such_method) {
   const Class& super_class = Class::Handle(current_class().SuperClass());
   if (super_class.IsNull()) {
@@ skipping 10 matching lines @@
   }
   if (super_func.IsNull()) {
     const String& no_such_method_name = String::Handle(Symbols::NoSuchMethod());
     super_func =
         Resolver::ResolveDynamicAnyArgs(super_class, no_such_method_name);
     ASSERT(!super_func.IsNull());
     *is_no_such_method = true;
   } else {
     *is_no_such_method = false;
   }
-  CheckFunctionIsCallable(token_pos, super_func);
   return super_func.raw();
 }
 
 
 // Lookup class in the core lib which also contains various VM
 // helper methods and classes. Allow look up of private classes.
 static RawClass* LookupCoreClass(const String& class_name) {
   const Library& core_lib = Library::Handle(Library::CoreLibrary());
   String& name = String::Handle(class_name.raw());
   if (class_name.CharAt(0) == Scanner::kPrivateIdentifierStart) {
@@ skipping 112 matching lines @@
     const bool kResolveGetter = false;
     bool is_no_such_method = false;
     const Function& super_operator = Function::ZoneHandle(
         GetSuperFunction(super_pos,
                          operator_function_name,
                          kResolveGetter,
                          &is_no_such_method));
     ArgumentListNode* op_arguments = new ArgumentListNode(super_pos);
     AstNode* receiver = LoadReceiver(super_pos);
     op_arguments->Add(receiver);
-    CheckFunctionIsCallable(super_pos, super_operator);
     if (is_no_such_method) {
       op_arguments = BuildNoSuchMethodArguments(
           super_pos, operator_function_name, *op_arguments);
     }
     super_op = new StaticCallNode(super_pos, super_operator, op_arguments);
   } else {
     ErrorMsg(super_pos, "illegal super operator call");
   }
   return super_op;
 }
@@ skipping 36 matching lines @@
                          &is_no_such_method));
 
     ASSERT(Token::Precedence(op) >= Token::Precedence(Token::kBIT_OR));
     AstNode* other_operand = ParseBinaryExpr(Token::Precedence(op) + 1);
 
     ArgumentListNode* op_arguments = new ArgumentListNode(operator_pos);
     AstNode* receiver = LoadReceiver(operator_pos);
     op_arguments->Add(receiver);
     op_arguments->Add(other_operand);
 
-    CheckFunctionIsCallable(operator_pos, super_operator);
     if (is_no_such_method) {
       op_arguments = BuildNoSuchMethodArguments(
           operator_pos, operator_function_name, *op_arguments);
     }
     super_op = new StaticCallNode(operator_pos, super_operator, op_arguments);
     if (negate_result) {
       super_op = new UnaryOpNode(operator_pos, Token::kNOT, super_op);
     }
   }
   return super_op;
@@ skipping 98 matching lines @@
   }
   String& error_message = String::Handle();
   if (!super_ctor.AreValidArguments(arguments->length(),
                                     arguments->names(),
                                     &error_message)) {
     ErrorMsg(supercall_pos,
              "invalid arguments passed to super constructor '%s()': %s",
              String::Handle(super_class.Name()).ToCString(),
              error_message.ToCString());
   }
-  CheckFunctionIsCallable(supercall_pos, super_ctor);
   current_block_->statements->Add(
       new StaticCallNode(supercall_pos, super_ctor, arguments));
 }
 
 
 AstNode* Parser::ParseSuperInitializer(const Class& cls,
                                        LocalVariable* receiver) {
   TRACE_PARSER("ParseSuperInitializer");
   ASSERT(CurrentToken() == Token::kSUPER);
   const intptr_t supercall_pos = TokenPos();
@@ skipping 39 matching lines @@
   }
   String& error_message = String::Handle();
   if (!super_ctor.AreValidArguments(arguments->length(),
                                     arguments->names(),
                                     &error_message)) {
     ErrorMsg(supercall_pos,
              "invalid arguments passed to super class constructor '%s': %s",
              ctor_name.ToCString(),
              error_message.ToCString());
   }
-  CheckFunctionIsCallable(supercall_pos, super_ctor);
   return new StaticCallNode(supercall_pos, super_ctor, arguments);
 }
 
 
 AstNode* Parser::ParseInitializer(const Class& cls,
                                   LocalVariable* receiver,
                                   GrowableArray<Field*>* initialized_fields) {
   TRACE_PARSER("ParseInitializer");
   const intptr_t field_pos = TokenPos();
   if (CurrentToken() == Token::kTHIS) {
@@ skipping 193 matching lines @@
   }
   String& error_message = String::Handle();
   if (!redirect_ctor.AreValidArguments(arguments->length(),
                                        arguments->names(),
                                        &error_message)) {
     ErrorMsg(call_pos,
              "invalid arguments passed to constructor '%s': %s",
              ctor_name.ToCString(),
              error_message.ToCString());
   }
-  CheckFunctionIsCallable(call_pos, redirect_ctor);
   current_block_->statements->Add(
       new StaticCallNode(call_pos, redirect_ctor, arguments));
 }
 
 
 SequenceNode* Parser::MakeImplicitConstructor(const Function& func) {
   ASSERT(func.IsConstructor());
   const intptr_t ctor_pos = TokenPos();
   OpenFunctionBlock(func);
   const Class& cls = Class::Handle(func.Owner());
@@ skipping 518 matching lines @@
   if (method->has_const && !method->IsFactoryOrConstructor()) {
     ErrorMsg(method->name_pos, "'const' not allowed for methods");
   }
   if (method->has_abstract && method->IsFactoryOrConstructor()) {
     ErrorMsg(method->name_pos, "constructor cannot be abstract");
   }
   if (method->has_const && method->IsConstructor()) {
     Class& cls = Class::Handle(library_.LookupClass(members->class_name()));
     cls.set_is_const();
   }
-  if (method->has_abstract && members->is_interface()) {
-    ErrorMsg(method->name_pos,
-             "'abstract' method only allowed in class definition");
-  }
-  if (method->has_external && members->is_interface()) {
-    ErrorMsg(method->name_pos,
-             "'external' method only allowed in class definition");
-  }
 
   // Parse the formal parameters.
   const bool are_implicitly_final = method->has_const;
   const bool allow_explicit_default_values = true;
   const intptr_t formal_param_pos = TokenPos();
   method->params.Clear();
   // Static functions do not have a receiver.
   // The first parameter of a factory is the AbstractTypeArguments vector of
   // the type of the instance to be allocated.
   if (!method->has_static || method->IsConstructor()) {
@@ skipping 130 matching lines @@
                "abstract method '%s' may not have a function body",
                method->name->ToCString());
     } else if (method->has_external) {
       ErrorMsg(method->name_pos,
                "external method '%s' may not have a function body",
                method->name->ToCString());
     } else if (method->IsFactoryOrConstructor() && method->has_const) {
       ErrorMsg(method->name_pos,
                "const constructor or factory '%s' may not have a function body",
                method->name->ToCString());
-    } else if (members->is_interface()) {
-      ErrorMsg(method->name_pos,
-               "function body not allowed in interface declaration");
     }
     if (method->redirect_name != NULL) {
       ErrorMsg(method->name_pos,
                "Constructor with redirection may not have a function body");
     }
     if (CurrentToken() == Token::kLBRACE) {
       SkipBlock();
     } else {
       ConsumeToken();
       SkipExpr();
       ExpectSemicolon();
     }
     method_end_pos = TokenPos();
   } else if (IsLiteral("native")) {
     if (method->has_abstract) {
       ErrorMsg(method->name_pos,
                "abstract method '%s' may not have a function body",
                method->name->ToCString());
-    } else if (members->is_interface()) {
-      ErrorMsg(method->name_pos,
-               "function body not allowed in interface declaration");
     } else if (method->IsFactoryOrConstructor() && method->has_const) {
       ErrorMsg(method->name_pos,
                "const constructor or factory '%s' may not be native",
                method->name->ToCString());
     }
     if (method->redirect_name != NULL) {
       ErrorMsg(method->name_pos,
                "Constructor with redirection may not have a function body");
     }
     ParseNativeDeclaration();
   } else {
     // We haven't found a method body. Issue error if one is required.
     const bool must_have_body =
-        !members->is_interface() &&
         method->has_static &&
         !method->has_external &&
         redirection_type.IsNull();
     if (must_have_body) {
       ErrorMsg(method->name_pos,
                "function body expected for method '%s'",
                method->name->ToCString());
     }
 
     if (CurrentToken() == Token::kSEMICOLON) {
       ConsumeToken();
-      if (!members->is_interface() &&
-          !method->has_static &&
+      if (!method->has_static &&
           !method->has_external &&
           !method->IsConstructor()) {
           // Methods, getters and setters without a body are
           // implicitly abstract.
         method->has_abstract = true;
       }
     } else {
       // Signature is not followed by semicolon or body. Issue an
       // appropriate error.
       const bool must_have_semicolon =
-          members->is_interface() ||
           (method->redirect_name != NULL) ||
           (method->IsConstructor() && method->has_const) ||
           method->has_external;
       if (must_have_semicolon) {
         ExpectSemicolon();
       } else {
         ErrorMsg(method->name_pos,
                  "function body or semicolon expected for method '%s'",
                  method->name->ToCString());
       }
@@ skipping 380 matching lines @@
   } else if (IsIdentifier()) {
     member.name = CurrentLiteral();
     member.name_pos = TokenPos();
     ConsumeToken();
   } else {
     ErrorMsg("identifier expected");
   }
 
   ASSERT(member.name != NULL);
   if (CurrentToken() == Token::kLPAREN || member.IsGetter()) {
-    if (members->is_interface() && member.has_static) {
-      if (member.has_factory) {
-        ErrorMsg("factory constructors are not allowed in interfaces");
-      } else {
-        ErrorMsg("static methods are not allowed in interfaces");
-      }
-    }
     // Constructor or method.
     if (member.type == NULL) {
       member.type = &Type::ZoneHandle(Type::DynamicType());
     }
     ASSERT(member.IsFactory() == member.has_factory);
     ParseMethodOrConstructor(members, &member);
   } else if (CurrentToken() ==  Token::kSEMICOLON ||
              CurrentToken() == Token::kCOMMA ||
              CurrentToken() == Token::kASSIGN) {
     // Field definition.
     if (member.has_const) {
       // const fields are implicitly final.
       member.has_final = true;
     }
     if (member.type == NULL) {
       if (member.has_final) {
         member.type = &Type::ZoneHandle(Type::DynamicType());
       } else {
         ErrorMsg("missing 'var', 'final', 'const' or type"
                  " in field declaration");
       }
     }
-    if (members->is_interface() && member.has_static && !member.has_final) {
-      ErrorMsg("static non-final fields are not allowed in interfaces");
-    }
     ParseFieldDefinition(members, &member);
   } else {
     UnexpectedToken();
   }
   current_member_ = NULL;
   members->AddMember(member);
 }
 
 
 void Parser::ParseClassDefinition(const GrowableObjectArray& pending_classes) {
@@ skipping 24 matching lines @@
                class_name.ToCString());
     }
     cls = Class::New(class_name, script_, classname_pos);
     library_.AddClass(cls);
   } else {
     if (!obj.IsClass()) {
       ErrorMsg(classname_pos, "'%s' is already defined",
                class_name.ToCString());
     }
     cls ^= obj.raw();
-    if (cls.is_interface()) {
-      ErrorMsg(classname_pos, "'%s' %s",
-               class_name.ToCString(),
-               is_patch ?
-                   "interface cannot be patched" :
-                   "is already defined as interface");
-    } else if (is_patch) {
+    if (is_patch) {
       String& patch = String::Handle(Symbols::New("patch "));
       patch = String::Concat(patch, class_name);
       patch = Symbols::New(patch);
       cls = Class::New(patch, script_, classname_pos);
       cls.set_library(library_);
     } else {
       // Not patching a class, but it has been found. This must be one of the
       // pre-registered classes from object.cc or a duplicate definition.
       if (cls.functions() != Object::empty_array()) {
         ErrorMsg(classname_pos, "class '%s' is already defined",
@@ skipping 13 matching lines @@
     const intptr_t type_pos = TokenPos();
     const AbstractType& type = AbstractType::Handle(
         ParseType(ClassFinalizer::kTryResolve));
     if (type.IsTypeParameter()) {
       ErrorMsg(type_pos,
                "class '%s' may not extend type parameter '%s'",
                class_name.ToCString(),
                String::Handle(type.UserVisibleName()).ToCString());
     }
     super_type ^= type.raw();
-    if (super_type.IsInterfaceType()) {
-      ErrorMsg(type_pos,
-               "class '%s' may implement, but cannot extend interface '%s'",
-               class_name.ToCString(),
-               String::Handle(super_type.UserVisibleName()).ToCString());
-    }
   } else {
     // No extends clause: Implicitly extend Object.
     super_type = Type::ObjectType();
   }
   ASSERT(!super_type.IsNull());
   cls.set_super_type(super_type);
 
   if (CurrentToken() == Token::kIMPLEMENTS) {
     Array& interfaces = Array::Handle();
     const intptr_t interfaces_pos = TokenPos();
@@ skipping 136 matching lines @@
   SetPosition(saved_pos);
   return is_alias_name;
 }
 
 
 void Parser::ParseFunctionTypeAlias(
     const GrowableObjectArray& pending_classes) {
   TRACE_PARSER("ParseFunctionTypeAlias");
   ExpectToken(Token::kTYPEDEF);
 
-  // Allocate an interface to hold the type parameters and their bounds.
+  // Allocate an abstract class to hold the type parameters and their bounds.
   // Make it the owner of the function type descriptor.
   const Class& alias_owner = Class::Handle(
       Class::New(String::Handle(Symbols::New(":alias_owner")),
                  Script::Handle(),
                  TokenPos()));
-  alias_owner.set_is_interface();
+
+  alias_owner.set_is_abstract();
   alias_owner.set_library(library_);
   set_current_class(alias_owner);
 
   // Parse the result type of the function type.
   AbstractType& result_type = Type::Handle(Type::DynamicType());
   if (CurrentToken() == Token::kVOID) {
     ConsumeToken();
     result_type = Type::VoidType();
   } else if (!IsFunctionTypeAliasName()) {
     // Type annotations in typedef are never ignored, even in unchecked mode.
@@ skipping 79 matching lines @@
   // This alias should not be marked as finalized yet, since it needs to be
   // checked in the class finalizer for illegal self references.
   ASSERT(!function_type_alias.IsCanonicalSignatureClass());
   ASSERT(!function_type_alias.is_finalized());
   library_.AddClass(function_type_alias);
   ExpectSemicolon();
   pending_classes.Add(function_type_alias, Heap::kOld);
 }
 
 
-// TODO(regis): Remove support for interfaces.
-void Parser::ParseInterfaceDefinition(
-    const GrowableObjectArray& pending_classes) {
-  TRACE_PARSER("ParseInterfaceDefinition");
-  const intptr_t interface_pos = TokenPos();
-  ExpectToken(Token::kINTERFACE);
-  const intptr_t interfacename_pos = TokenPos();
-  String& interface_name =
-      *ExpectUserDefinedTypeIdentifier("interface name expected");
-  if (FLAG_trace_parser) {
-    OS::Print("TopLevel parsing interface '%s'\n", interface_name.ToCString());
-  }
-  Class& interface = Class::Handle();
-  Object& obj = Object::Handle(library_.LookupLocalObject(interface_name));
-  if (obj.IsNull()) {
-    interface = Class::NewInterface(interface_name, script_, interfacename_pos);
-    library_.AddClass(interface);
-  } else {
-    if (!obj.IsClass()) {
-      ErrorMsg(interfacename_pos, "'%s' is already defined",
-               interface_name.ToCString());
-    }
-    interface ^= obj.raw();
-    if (!interface.is_interface()) {
-      ErrorMsg(interfacename_pos,
-               "'%s' is already defined as class",
-               interface_name.ToCString());
-    } else if (interface.functions() != Object::empty_array()) {
-      ErrorMsg(interfacename_pos,
-               "interface '%s' is already defined",
-               interface_name.ToCString());
-    }
-  }
-  ASSERT(!interface.IsNull());
-  ASSERT(interface.functions() == Object::empty_array());
-  set_current_class(interface);
-  ParseTypeParameters(interface);
-
-  if (CurrentToken() == Token::kEXTENDS) {
-    Array& interfaces = Array::Handle();
-    const intptr_t interfaces_pos = TokenPos();
-    interfaces = ParseInterfaceList();
-    AddInterfaces(interfaces_pos, interface, interfaces);
-  }
-
-  ExpectToken(Token::kLBRACE);
-  ClassDesc members(interface, interface_name, true, interface_pos);
-  while (CurrentToken() != Token::kRBRACE) {
-    ParseClassMemberDefinition(&members);
-  }
-  ExpectToken(Token::kRBRACE);
-
-  if (members.has_constructor()) {
-    ErrorMsg(interfacename_pos,
-             "interface '%s' cannot declare constructor",
-             interface_name.ToCString());
-  }
-
-  Array& array = Array::Handle();
-  array = Array::MakeArray(members.fields());
-  interface.SetFields(array);
-
-  // Creating a new array for functions marks the interface as parsed.
-  array = Array::MakeArray(members.functions());
-  interface.SetFunctions(array);
-  ASSERT(interface.is_interface());
-
-  pending_classes.Add(interface, Heap::kOld);
-}
-
-
 // Consumes exactly one right angle bracket. If the current token is a single
 // bracket token, it is consumed normally. However, if it is a double or triple
 // bracket, it is replaced by a single or double bracket token without
 // incrementing the token index.
 void Parser::ConsumeRightAngleBracket() {
   if (token_kind_ == Token::kGT) {
     ConsumeToken();
   } else if (token_kind_ == Token::kSHR) {
     token_kind_ = Token::kGT;
   } else {
@@ skipping 231 matching lines @@
   Array& cls_interfaces = Array::Handle(cls.interfaces());
   for (intptr_t i = 0; i < cls_interfaces.Length(); i++) {
     interface ^= cls_interfaces.At(i);
     all_interfaces.Add(interface);
   }
   // Now add the new interfaces.
   for (intptr_t i = 0; i < interfaces.Length(); i++) {
     AbstractType& interface = AbstractType::ZoneHandle();
     interface ^= interfaces.At(i);
     if (interface.IsTypeParameter()) {
-      if (cls.is_interface()) {
-        ErrorMsg(interfaces_pos,
-                 "interface '%s' may not extend type parameter '%s'",
-                 String::Handle(cls.Name()).ToCString(),
-                 String::Handle(interface.UserVisibleName()).ToCString());
-      } else {
-        ErrorMsg(interfaces_pos,
-                 "class '%s' may not implement type parameter '%s'",
-                 String::Handle(cls.Name()).ToCString(),
-                 String::Handle(interface.UserVisibleName()).ToCString());
-      }
+      ErrorMsg(interfaces_pos,
+               "class '%s' may not implement type parameter '%s'",
+               String::Handle(cls.Name()).ToCString(),
+               String::Handle(interface.UserVisibleName()).ToCString());
     }
     AddInterfaceIfUnique(interfaces_pos, all_interfaces, interface);
   }
   cls_interfaces = Array::MakeArray(all_interfaces);
   cls.set_interfaces(cls_interfaces);
 }
 
 
 void Parser::ParseTopLevelVariable(TopLevel* top_level) {
   TRACE_PARSER("ParseTopLevelVariable");
@@ skipping 659 matching lines @@
   }
 
   while (true) {
     set_current_class(Class::Handle());  // No current class.
     SkipMetadata();
     if (CurrentToken() == Token::kCLASS) {
       ParseClassDefinition(pending_classes);
     } else if ((CurrentToken() == Token::kTYPEDEF) &&
                (LookaheadToken(1) != Token::kLPAREN)) {
       ParseFunctionTypeAlias(pending_classes);
-    } else if (CurrentToken() == Token::kINTERFACE) {
-      ParseInterfaceDefinition(pending_classes);
     } else if ((CurrentToken() == Token::kABSTRACT) &&
         (LookaheadToken(1) == Token::kCLASS)) {
       ParseClassDefinition(pending_classes);
     } else if (is_patch_source() && IsLiteral("patch") &&
                (LookaheadToken(1) == Token::kCLASS)) {
       ParseClassDefinition(pending_classes);
     } else {
       set_current_class(toplevel_class);
       if (IsVariableDeclaration()) {
         ParseTopLevelVariable(&top_level);
@@ skipping 1388 matching lines @@
                                 ArgumentListNode* arguments) {
   const Class& cls = Class::Handle(LookupCoreClass(cls_name));
   ASSERT(!cls.IsNull());
   const Function& func = Function::ZoneHandle(
       Resolver::ResolveStatic(cls,
                               func_name,
                               arguments->length(),
                               arguments->names(),
                               Resolver::kIsQualified));
   ASSERT(!func.IsNull());
-  CheckFunctionIsCallable(arguments->token_pos(), func);
   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,
       Integer::ZoneHandle(Integer::New(end))));
@@ skipping 1417 matching lines @@
         return new ClosureCallNode(call_pos, closure, arguments);
       }
     } else {
       EnsureExpressionTemp();
       closure = GenerateStaticFieldLookup(field, call_pos);
       return new ClosureCallNode(call_pos, closure, arguments);
     }
     // Could not resolve static method: throw a NoSuchMethodError.
     return ThrowNoSuchMethodError(ident_pos, func_name);
   }
-  CheckFunctionIsCallable(call_pos, func);
   return new StaticCallNode(call_pos, func, arguments);
 }
 
 
 AstNode* Parser::ParseInstanceCall(AstNode* receiver, const String& func_name) {
   TRACE_PARSER("ParseInstanceCall");
   const intptr_t call_pos = TokenPos();
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg(call_pos, "left parenthesis expected");
   }
@@ skipping 1747 matching lines @@
     }
     return ThrowTypeError(type_pos, type);
   }
 
   // Resolve the type and optional identifier to a constructor or factory.
   Class& type_class = Class::Handle(type.type_class());
   const String& type_class_name = String::Handle(type_class.Name());
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::ZoneHandle(type.arguments());
 
-  // The constructor class and its name are those of the parsed type, unless the
-  // parsed type is an interface and a default factory class is specified, in
-  // which case constructor_class and constructor_class_name are modified below.
-  Class& constructor_class = Class::ZoneHandle(type_class.raw());
-  String& constructor_class_name = String::Handle(type_class_name.raw());
-
   // A constructor has an implicit 'this' parameter (instance to construct)
   // and a factory has an implicit 'this' parameter (type_arguments).
   // A constructor has a second implicit 'phase' parameter.
   intptr_t arguments_length = arguments->length() + 2;
 
-  if (type_class.is_interface()) {
-    // TODO(regis): Remove support for interfaces.
-    UNREACHABLE();
-  }
-
   // An additional type check of the result of a redirecting factory may be
   // required.
   AbstractType& type_bound = AbstractType::ZoneHandle();
 
   // Make sure that an appropriate constructor exists.
   const String& constructor_name =
-      BuildConstructorName(constructor_class_name, named_constructor);
+      BuildConstructorName(type_class_name, named_constructor);
   Function& constructor = Function::ZoneHandle(
-      constructor_class.LookupConstructor(constructor_name));
+      type_class.LookupConstructor(constructor_name));
   if (constructor.IsNull()) {
-    constructor = constructor_class.LookupFactory(constructor_name);
+    constructor = type_class.LookupFactory(constructor_name);
     if (constructor.IsNull()) {
       const String& external_constructor_name =
-          (named_constructor ? constructor_name : constructor_class_name);
+          (named_constructor ? constructor_name : type_class_name);
       // Replace the type with a malformed type and compile a throw or report a
       // compile-time error if the constructor is const.
       type = ClassFinalizer::NewFinalizedMalformedType(
           Error::Handle(),  // No previous error.
           current_class(),
           call_pos,
           ClassFinalizer::kTryResolve,  // No compile-time error.
           "class '%s' has no constructor or factory named '%s'",
-          String::Handle(constructor_class.Name()).ToCString(),
+          String::Handle(type_class.Name()).ToCString(),
           external_constructor_name.ToCString());
       if (is_const) {
         const Error& error = Error::Handle(type.malformed_error());
         ErrorMsg(error);
       }
       return ThrowNoSuchMethodError(call_pos, external_constructor_name);
     } else if (constructor.IsRedirectingFactory()) {
       Type& redirect_type = Type::Handle(constructor.RedirectionType());
       if (!redirect_type.IsMalformed() && !redirect_type.IsInstantiated()) {
         // The type arguments of the redirection type are instantiated from the
         // type arguments of the parsed type of the 'new' or 'const' expression.
         redirect_type ^= redirect_type.InstantiateFrom(type_arguments);
       }
       if (redirect_type.IsMalformed()) {
         if (is_const) {
           const Error& error = Error::Handle(redirect_type.malformed_error());
           ErrorMsg(error);
         }
         return ThrowTypeError(redirect_type.token_pos(), redirect_type);
       }
       if (FLAG_enable_type_checks && !redirect_type.IsSubtypeOf(type, NULL)) {
         // Additional type checking of the result is necessary.
         type_bound = type.raw();
       }
       type = redirect_type.raw();
       type_class = type.type_class();
       type_arguments = type.arguments();
       constructor = constructor.RedirectionTarget();
       ASSERT(!constructor.IsNull());
-      constructor_class = constructor.Owner();
-      ASSERT(type_class.raw() == constructor_class.raw());
     }
     if (constructor.IsFactory()) {
       // A factory does not have the implicit 'phase' parameter.
       arguments_length -= 1;
     }
   }
 
   // It is ok to call a factory method of an abstract class, but it is
   // a dynamic error to instantiate an abstract class.
   ASSERT(!constructor.IsNull());
-  if (constructor_class.is_abstract() && !constructor.IsFactory()) {
+  if (type_class.is_abstract() && !constructor.IsFactory()) {
     ArgumentListNode* arguments = new ArgumentListNode(type_pos);
     arguments->Add(new LiteralNode(
         TokenPos(), Integer::ZoneHandle(Integer::New(type_pos))));
     arguments->Add(new LiteralNode(
-        TokenPos(), String::ZoneHandle(constructor_class_name.raw())));
+        TokenPos(), String::ZoneHandle(type_class_name.raw())));
     const String& cls_name =
         String::Handle(Symbols::AbstractClassInstantiationError());
     const String& func_name = String::Handle(Symbols::ThrowNew());
     return MakeStaticCall(cls_name, func_name, arguments);
   }
   String& error_message = String::Handle();
   if (!constructor.AreValidArguments(arguments_length,
                                      arguments->names(),
                                      &error_message)) {
     const String& external_constructor_name =
-        (named_constructor ? constructor_name : constructor_class_name);
+        (named_constructor ? constructor_name : type_class_name);
     if (is_const) {
       ErrorMsg(call_pos,
                "invalid arguments passed to constructor '%s' "
                "for class '%s': %s",
                external_constructor_name.ToCString(),
-               String::Handle(constructor_class.Name()).ToCString(),
+               String::Handle(type_class.Name()).ToCString(),
                error_message.ToCString());
     }
     return ThrowNoSuchMethodError(call_pos, external_constructor_name);
   }
 
-  // Now that the constructor to be called is identified, finalize the type
-  // argument vector to be passed.
-  // The type argument vector of the parsed type was finalized in ParseType.
-  // If the constructor class was changed from the interface class to the
-  // factory class, we need to finalize the type argument vector again, because
-  // it may be longer due to the factory class extending a class, or/and because
-  // the bounds on the factory class may be tighter than on the interface.
-  if (!constructor.IsNull() && (constructor_class.raw() != type_class.raw())) {
-    const intptr_t num_type_parameters = constructor_class.NumTypeParameters();
-    TypeArguments& temp_type_arguments = TypeArguments::Handle();
-    if (!type_arguments.IsNull()) {
-      // Copy the parsed type arguments starting at offset 0, because interfaces
-      // have no super types.
-      ASSERT(type_class.NumTypeArguments() == type_class.NumTypeParameters());
-      const intptr_t num_type_arguments = type_arguments.Length();
-      temp_type_arguments = TypeArguments::New(num_type_parameters, Heap::kNew);
-      AbstractType& type_argument = AbstractType::Handle();
-      for (intptr_t i = 0; i < num_type_parameters; i++) {
-        if (i < num_type_arguments) {
-          type_argument = type_arguments.TypeAt(i);
-        } else {
-          type_argument = Type::DynamicType();
-        }
-        temp_type_arguments.SetTypeAt(i, type_argument);
-      }
-    }
-    Type& temp_type = Type::Handle(Type::New(
-         constructor_class, temp_type_arguments, type.token_pos(), Heap::kNew));
-    // No need to canonicalize temporary type.
-    temp_type ^= ClassFinalizer::FinalizeType(
-        current_class(), temp_type, ClassFinalizer::kFinalize);
-    // The type argument vector may have been expanded with the type arguments
-    // of the super type when finalizing the temporary type.
-    type_arguments = temp_type.arguments();
-    // The type parameter bounds of the factory class may be more specific than
-    // the type parameter bounds of the interface class. Therefore, although
-    // type was not malformed, temp_type may be malformed.
-    if (!type.IsMalformed() && temp_type.IsMalformed()) {
-      const Error& error = Error::Handle(temp_type.malformed_error());
-      type.set_malformed_error(error);
-    }
-  }
   // Return a throw in case of a malformed type or report a compile-time error
   // if the constructor is const.
   if (type.IsMalformed()) {
     if (is_const) {
       const Error& error = Error::Handle(type.malformed_error());
       ErrorMsg(error);
     }
     return ThrowTypeError(type_pos, type);
   }
   type_arguments ^= type_arguments.Canonicalize();
   // Make the constructor call.
   AstNode* new_object = NULL;
   if (is_const) {
     if (!constructor.is_const()) {
       ErrorMsg("'const' requires const constructor: '%s'",
           String::Handle(constructor.name()).ToCString());
     }
     const Object& constructor_result = Object::Handle(
-        EvaluateConstConstructorCall(constructor_class,
+        EvaluateConstConstructorCall(type_class,
                                      type_arguments,
                                      constructor,
                                      arguments));
     if (constructor_result.IsUnhandledException()) {
       new_object = GenerateRethrow(new_pos, constructor_result);
     } else {
       const Instance& const_instance = Instance::Cast(constructor_result);
       new_object = new LiteralNode(new_pos,
                                    Instance::ZoneHandle(const_instance.raw()));
       if (!type_bound.IsNull()) {
         ASSERT(!type_bound.IsMalformed());
         Error& malformed_error = Error::Handle();
         if (!const_instance.IsInstanceOf(type_bound,
                                          TypeArguments::Handle(),
                                          &malformed_error)) {
           type_bound = ClassFinalizer::NewFinalizedMalformedType(
               malformed_error,
               current_class(),
               new_pos,
               ClassFinalizer::kTryResolve,  // No compile-time error.
               "const factory result is not an instance of '%s'",
               String::Handle(type_bound.UserVisibleName()).ToCString());
           new_object = ThrowTypeError(new_pos, type_bound);
         }
         type_bound = AbstractType::null();
       }
     }
   } else {
-    CheckFunctionIsCallable(new_pos, constructor);
     CheckConstructorCallTypeArguments(new_pos, constructor, type_arguments);
     if (!type_arguments.IsNull() &&
         !type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
       CaptureInstantiator();
     }
     // If the type argument vector is not instantiated, we verify in checked
     // mode at runtime that it is within its declared bounds.
     new_object = CreateConstructorCallNode(
@@ skipping 605 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart