Remove support for interfaces.

runtime/vm/parser.h

 // 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.
 
 #ifndef VM_PARSER_H_
 #define VM_PARSER_H_
 
 #include "include/dart_api.h"
 
 #include "vm/ast.h"
@@ skipping 100 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ParsedFunction);
 };
 
 
 class Parser : public ValueObject {
  public:
   Parser(const Script& script, const Library& library);
   Parser(const Script& script, const Function& function, intptr_t token_pos);
 
   // Parse the top level of a whole script file and register declared classes
-  // and interfaces in the given library.
+  // in the given library.
   static void ParseCompilationUnit(const Library& library,
                                    const Script& script);
 
   static void ParseFunction(ParsedFunction* parsed_function);
 
   // Format and print a message with source location.
   // A null script means no source and a negative token_pos means no position.
   static void PrintMessage(const Script& script,
                            intptr_t token_pos,
                            const char* message_header,
@@ skipping 44 matching lines @@
   // Therefore, the statements being parsed may or may not belong to the body
   // of the current_function(); they may belong to nested functions.
   // innermost_function() is the function that is currently being parsed.
   // It is either the same as current_function(), or a lexically nested
   // function.
   // The function level of the current parsing scope reflects the function
   // nesting. The function level is zero while parsing the body of the
   // current_function(), but is greater than zero while parsing the body of
   // local functions nested in current_function().
 
-  // The class or interface being parsed.
+  // The class being parsed.
   const Class& current_class() const;
   void set_current_class(const Class& value);
 
   // Parsing a library or a regular source script.
   bool is_library_source() const {
     return (script_.kind() == RawScript::kScriptTag) ||
         (script_.kind() == RawScript::kLibraryTag);
   }
 
   bool is_part_source() const {
@@ skipping 89 matching lines @@
   RawObject* EvaluateConstConstructorCall(
       const Class& type_class,
       const AbstractTypeArguments& type_arguments,
       const Function& constructor,
       ArgumentListNode* arguments);
   AstNode* FoldConstExpr(intptr_t expr_pos, AstNode* expr);
 
   // Support for parsing of scripts.
   void ParseTopLevel();
   void ParseClassDefinition(const GrowableObjectArray& pending_classes);
-  void ParseInterfaceDefinition(const GrowableObjectArray& pending_classes);
   void ParseFunctionTypeAlias(const GrowableObjectArray& pending_classes);
   void ParseTopLevelVariable(TopLevel* top_level);
   void ParseTopLevelFunction(TopLevel* top_level);
   void ParseTopLevelAccessor(TopLevel* top_level);
 
   // Support for parsing libraries.
   Dart_Handle CallLibraryTagHandler(Dart_LibraryTag tag,
                                     intptr_t token_pos,
                                     const String& url);
   void ParseIdentList(GrowableObjectArray* names);
@@ skipping 38 matching lines @@
                                     LocalVariable* receiver);
   AstNode* ParseSuperInitializer(const Class& cls, LocalVariable* receiver);
   AstNode* ParseInitializer(const Class& cls,
                             LocalVariable* receiver,
                             GrowableArray<Field*>* initialized_fields);
   void ParseConstructorRedirection(const Class& cls, LocalVariable* receiver);
   void ParseInitializers(const Class& cls,
                          LocalVariable* receiver,
                          GrowableArray<Field*>* initialized_fields);
   String& ParseNativeDeclaration();
-  // TODO(srdjan): Return TypeArguments instead of Array?
   RawArray* ParseInterfaceList();
   void AddInterfaceIfUnique(intptr_t interfaces_pos,
                             const GrowableObjectArray& interface_list,
                             const AbstractType& interface);
   void AddInterfaces(intptr_t interfaces_pos,
                      const Class& cls,
                      const Array& interfaces);
   StaticCallNode* BuildInvocationMirrorAllocation(
       intptr_t call_pos,
       const String& function_name,
@@ skipping 203 matching lines @@
 
   SequenceNode* MakeImplicitConstructor(const Function& func);
   AstNode* MakeStaticCall(const String& cls_name,
                           const String& func_name,
                           ArgumentListNode* arguments);
   String& Interpolate(ArrayNode* values);
   AstNode* MakeAssertCall(intptr_t begin, intptr_t end);
   AstNode* ThrowTypeError(intptr_t type_pos, const AbstractType& type);
   AstNode* ThrowNoSuchMethodError(intptr_t call_pos, const String& name);
 
-  void CheckFunctionIsCallable(intptr_t token_pos, const Function& function);
   void CheckOperatorArity(const MemberDesc& member);
 
   const LocalVariable* GetIncrementTempLocal();
   void EnsureExpressionTemp();
   AstNode* CreateAssignmentNode(AstNode* original, AstNode* rhs);
   AstNode* InsertClosureCallNodes(AstNode* condition);
 
   ConstructorCallNode* CreateConstructorCallNode(
       intptr_t token_pos,
       const AbstractTypeArguments& type_arguments,
       const Function& constructor,
       ArgumentListNode* arguments);
 
 
   const Script& script_;
   TokenStream::Iterator tokens_iterator_;
   Token::Kind token_kind_;  // Cached token kind for current token.
   Block* current_block_;
 
   // is_top_level_ is true if parsing the "top level" of a compilation unit,
-  // that is interface and class definitions.
+  // that is class definitions, function type aliases, global functions,
+  // global variables.
   bool is_top_level_;
 
   // The member currently being parsed during "top level" parsing.
   MemberDesc* current_member_;
 
   // Parser mode to allow/disallow function literals. This is used in
   // constructor initializer expressions to handle ambiguous grammar.
   bool SetAllowFunctionLiterals(bool value);
   bool allow_function_literals_;
 
   // The function currently being compiled.
   const Function& current_function_;
 
   // The function currently being parsed.
   Function& innermost_function_;
 
-  // The class or interface currently being parsed, or the owner class of the
+  // The class currently being parsed, or the owner class of the
   // function currently being parsed. It is used for primary identifier lookups.
   Class& current_class_;
 
   // The current library (and thus class dictionary) used to resolve names.
   const Library& library_;
 
   // List of try blocks seen so far, this is used to generate inlined finally
   // code at all points in the try block where an exit from the block is
   // done using 'return', 'break' or 'continue' statements.
   TryBlocks* try_blocks_list_;
 
   // Allocate temporary only once per function.
   LocalVariable* expression_temp_;
 
   DISALLOW_COPY_AND_ASSIGN(Parser);
 };
 
 }  // namespace dart
 
 #endif  // VM_PARSER_H_