- Allow parsing of external methods.

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 434 matching lines @@
   ZoneGrowableArray<ParamDesc>* parameters;
 };
 
 
 struct MemberDesc {
   MemberDesc() {
     Clear();
   }
   void Clear() {
     has_abstract = false;
+    has_external = false;
     has_final = false;
     has_const = false;
     has_static = false;
     has_var = false;
     has_factory = false;
     type = NULL;
     name_pos = 0;
     name = NULL;
     redirect_name = NULL;
     params.Clear();
     kind = RawFunction::kRegularFunction;
   }
   bool IsConstructor() const {
     return (kind == RawFunction::kConstructor) && !has_static;
   }
   bool IsFactory() const {
     return (kind == RawFunction::kConstructor) && has_static;
   }
   bool IsFactoryOrConstructor() const {
     return (kind == RawFunction::kConstructor);
   }
   bool IsGetter() const {
     return kind == RawFunction::kGetterFunction;
   }
   bool IsSetter() const {
     return kind == RawFunction::kSetterFunction;
   }
   bool has_abstract;
+  bool has_external;
   bool has_final;
   bool has_const;
   bool has_static;
   bool has_var;
   bool has_factory;
   const AbstractType* type;
   intptr_t name_pos;
   String* name;
   String* redirect_name;  // For constructors: NULL or redirected constructor.
   ParamList params;
@@ skipping 565 matching lines @@
       ParamList func_params;
       const bool no_explicit_default_values = false;
       ParseFormalParameterList(no_explicit_default_values, &func_params);
 
       // The field 'is_static' has no meaning for signature functions.
       const Function& signature_function = Function::Handle(
           Function::New(*parameter.name,
                         RawFunction::kSignatureFunction,
                         /* is_static = */ false,
                         /* is_const = */ false,
+                        /* is_external = */ false,
                         parameter.name_pos));
       signature_function.set_owner(current_class());
       signature_function.set_result_type(result_type);
       AddFormalParamsToFunction(&func_params, signature_function);
       const String& signature = String::Handle(signature_function.Signature());
       // Lookup the signature class, i.e. the class whose name is the signature.
       // We only lookup in the current library, but not in its imports, and only
       // create a new canonical signature class if it does not exist yet.
       Class& signature_class = Class::ZoneHandle(
           library_.LookupLocalClass(signature));
@@ skipping 1080 matching lines @@
     ParseStatementSequence();
     ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
     ConsumeToken();
     const intptr_t expr_pos = TokenPos();
     AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
     ASSERT(expr != NULL);
     current_block_->statements->Add(new ReturnNode(expr_pos, expr));
   } else if (IsLiteral("native")) {
     ParseNativeFunctionBlock(&params, func);
+  } else if (func.is_external()) {
+    // Body of an external method contains a single throw.
+    current_block_->statements->Add(
+        new ThrowNode(TokenPos(),
+            new LiteralNode(TokenPos(),
+                String::ZoneHandle(
+                    Symbols::New("External implementation missing."))), NULL));
   } else {
     UnexpectedToken();
   }
   SequenceNode* body = CloseBlock();
   current_block_->statements->Add(body);
   innermost_function_ = saved_innermost_function.raw();
   return CloseBlock();
 }
 
 
@@ skipping 108 matching lines @@
     ErrorMsg(method->name_pos, "constructor cannot be 'static'");
   }
   if (method->IsConstructor() && method->has_const) {
     Class& cls = Class::ZoneHandle(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");
+  }
 
   if (members->FunctionNameExists(*method->name, method->kind)) {
     ErrorMsg(method->name_pos,
              "field or method '%s' already defined", method->name->ToCString());
   }
 
   // Parse the formal parameters.
   // The first parameter of factory methods is an implicit parameter called
   // 'this' of type AbstractTypeArguments.
   const bool has_this_param =
@@ skipping 71 matching lines @@
   // Only constructors can redirect to another method.
   ASSERT((method->redirect_name == NULL) || method->IsConstructor());
 
   intptr_t method_end_pos = method_pos;
   if ((CurrentToken() == Token::kLBRACE) ||
       (CurrentToken() == Token::kARROW)) {
     if (method->has_abstract) {
       ErrorMsg(method->name_pos,
                "abstract method '%s' may not have function body",
                method->name->ToCString());
+    } else if (method->has_external) {
+      ErrorMsg(method->name_pos,
+               "external method '%s' may not have function body",
+               method->name->ToCString());
     } else if (method->IsConstructor() && method->has_const) {
       ErrorMsg(method->name_pos,
                "const constructor '%s' may not have function body",
                method->name->ToCString());
     } else if (method->IsFactory() && method->has_const) {
       ErrorMsg(method->name_pos,
                "const factory '%s' may not have function body",
                method->name->ToCString());
     } else if (members->is_interface()) {
       ErrorMsg(method->name_pos,
@@ skipping 17 matching lines @@
                "function body not allowed in interface declaration");
     } else if (method->IsConstructor() && method->has_const) {
       ErrorMsg(method->name_pos,
                "const constructor '%s' may not have function body",
                method->name->ToCString());
     }
     ParseNativeDeclaration();
   } else if (CurrentToken() == Token::kSEMICOLON) {
     if (members->is_interface() ||
         method->has_abstract ||
+        method->has_external ||
         (method->redirect_name != NULL) ||
         method->IsConstructor()) {
       ConsumeToken();
     } else {
       ErrorMsg(method->name_pos,
                "function body expected for method '%s'",
                method->name->ToCString());
     }
   } else {
     if (members->is_interface() ||
         method->has_abstract ||
+        method->has_external ||
         (method->redirect_name != NULL) ||
         (method->IsConstructor() && method->has_const)) {
       ExpectSemicolon();
     } else {
       ErrorMsg(method->name_pos,
                "function body expected for method '%s'",
                method->name->ToCString());
     }
   }
 
   RawFunction::Kind function_kind;
   if (method->IsFactoryOrConstructor()) {
     function_kind = RawFunction::kConstructor;
   } else if (method->has_abstract) {
     function_kind = RawFunction::kAbstract;
   } else if (method->IsGetter()) {
     function_kind = RawFunction::kGetterFunction;
   } else if (method->IsSetter()) {
     function_kind = RawFunction::kSetterFunction;
   } else {
     function_kind = RawFunction::kRegularFunction;
   }
   Function& func = Function::Handle(
       Function::New(*method->name,
                     function_kind,
                     method->has_static,
                     method->has_const,
+                    method->has_external,
                     method_pos));
   func.set_result_type(*method->type);
   func.set_end_token_pos(method_end_pos);
 
   // No need to resolve parameter types yet, or add parameters to local scope.
   ASSERT(is_top_level_);
   AddFormalParamsToFunction(&method->params, func);
   members->AddFunction(func);
 }
 
 
 void Parser::ParseFieldDefinition(ClassDesc* members, MemberDesc* field) {
   TRACE_PARSER("ParseFieldDefinition");
   // The parser has read the first field name and is now at the token
   // after the field name.
   ASSERT(CurrentToken() == Token::kSEMICOLON ||
          CurrentToken() == Token::kCOMMA ||
          CurrentToken() == Token::kASSIGN);
   ASSERT(field->type != NULL);
   ASSERT(field->name_pos > 0);
   ASSERT(current_member_ == field);
 

[hausner, 2012/07/30 16:25:59]

Can a field be external? If not, this needs to be checked here.

[Ivan Posva, 2012/07/30 22:33:33]

Done.

   if (field->has_const) {
     ErrorMsg("keyword 'const' not allowed in field declaration");
   }
   if (field->has_abstract) {
     ErrorMsg("keyword 'abstract' not allowed in field declaration");
   }
   if (field->has_factory) {
     ErrorMsg("keyword 'factory' not allowed in field declaration");
   }
   if (members->FieldNameExists(*field->name)) {
@@ skipping 29 matching lines @@
     class_field.set_type(*field->type);
     class_field.set_has_initializer(has_initializer);
     members->AddField(class_field);
 
     // For static final fields, set value to "uninitialized" and
     // create a kConstImplicitGetter getter method.
     if (field->has_static && has_initializer) {
       class_field.set_value(Instance::Handle(Object::sentinel()));
       String& getter_name = String::Handle(Field::GetterSymbol(*field->name));
       getter = Function::New(getter_name, RawFunction::kConstImplicitGetter,
-                             field->has_static, field->has_final,
+                             field->has_static, field->has_final, false,
                              field->name_pos);
       getter.set_result_type(*field->type);
       members->AddFunction(getter);
     }
 
     // For instance fields, we create implicit getter and setter methods.
     if (!field->has_static) {
       String& getter_name = String::Handle(Field::GetterSymbol(*field->name));
       getter = Function::New(getter_name, RawFunction::kImplicitGetter,
-                             field->has_static, field->has_final,
+                             field->has_static, field->has_final, false,
                              field->name_pos);
       ParamList params;
       params.AddReceiver(TokenPos());
       getter.set_result_type(*field->type);
       AddFormalParamsToFunction(&params, getter);
       members->AddFunction(getter);
       if (!field->has_final) {
         // Build a setter accessor for non-const fields.
         String& setter_name = String::Handle(Field::SetterSymbol(*field->name));
         setter = Function::New(setter_name, RawFunction::kImplicitSetter,
-                               field->has_static, field->has_final,
+                               field->has_static, field->has_final, false,
                                field->name_pos);
         ParamList params;
         params.AddReceiver(TokenPos());
         params.AddFinalParameter(TokenPos(),
                                  &String::ZoneHandle(Symbols::Value()),
                                  field->type);
         setter.set_result_type(Type::Handle(Type::VoidType()));
         AddFormalParamsToFunction(&params, setter);
         members->AddFunction(setter);
       }
@@ skipping 33 matching lines @@
 
 void Parser::ParseClassMemberDefinition(ClassDesc* members) {
   TRACE_PARSER("ParseClassMemberDefinition");
   MemberDesc member;
   current_member_ = &member;
   if ((CurrentToken() == Token::kABSTRACT) &&
       (LookaheadToken(1) != Token::kLPAREN)) {
     ConsumeToken();
     member.has_abstract = true;
   }
+  if ((CurrentToken() == Token::kEXTERNAL) &&
+      (LookaheadToken(1) != Token::kLPAREN)) {
+    ConsumeToken();
+    member.has_external = true;
+  }
   if ((CurrentToken() == Token::kSTATIC) &&
       (LookaheadToken(1) != Token::kLPAREN)) {
     ConsumeToken();
     member.has_static = true;
   }
   if (CurrentToken() == Token::kCONST) {
     ConsumeToken();
     member.has_const = true;
   } else if (CurrentToken() == Token::kFINAL) {
     ConsumeToken();
@@ skipping 296 matching lines @@
         String::Concat(class_desc->class_name(),
                        String::Handle(Symbols::Dot())));
     ctor_name = Symbols::New(ctor_name);
     // The token position for the implicit constructor is the 'class'
     // keyword of the constructor's class.
     Function& ctor = Function::Handle(
         Function::New(ctor_name,
                       RawFunction::kConstructor,
                       /* is_static = */ false,
                       /* is_const = */ false,
+                      /* is_external = */ false,
                       class_desc->token_pos()));
     ParamList params;
     // Add implicit 'this' parameter.
     params.AddReceiver(TokenPos());
     // Add implicit parameter for construction phase.
     params.AddFinalParameter(
         TokenPos(),
         &String::ZoneHandle(Symbols::PhaseParameter()),
         &Type::ZoneHandle(Type::DynamicType()));
 
@@ skipping 98 matching lines @@
   }
   ParamList func_params;
   const bool no_explicit_default_values = false;
   ParseFormalParameterList(no_explicit_default_values, &func_params);
   // The field 'is_static' has no meaning for signature functions.
   Function& signature_function = Function::Handle(
       Function::New(*alias_name,
                     RawFunction::kSignatureFunction,
                     /* is_static = */ false,
                     /* is_const = */ false,
+                    /* is_external = */ false,
                     alias_name_pos));
   signature_function.set_owner(alias_owner);
   signature_function.set_result_type(result_type);
   AddFormalParamsToFunction(&func_params, signature_function);
   const String& signature = String::Handle(signature_function.Signature());
   if (FLAG_trace_parser) {
     OS::Print("TopLevel parsing function type alias '%s'\n",
               signature.ToCString());
   }
   // Lookup the signature class, i.e. the class whose name is the signature.
@@ skipping 409 matching lines @@
     field.set_value(Instance::Handle(Instance::null()));
     top_level->fields.Add(field);
     library_.AddObject(field, var_name);
     if (CurrentToken() == Token::kASSIGN) {
       ConsumeToken();
       SkipExpr();
       field.set_value(Instance::Handle(Object::sentinel()));
       // Create a static const getter.
       String& getter_name = String::ZoneHandle(Field::GetterSymbol(var_name));
       getter = Function::New(getter_name, RawFunction::kConstImplicitGetter,
-                             is_static, is_final, name_pos);
+                             is_static, is_final, false, name_pos);
       getter.set_result_type(type);
       top_level->functions.Add(getter);
     } else if (is_final) {
       ErrorMsg(name_pos, "missing initializer for final variable");
     }
 
     if (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
     } else if (CurrentToken() == Token::kSEMICOLON) {
       ConsumeToken();
       break;
     } else {
       ExpectSemicolon();  // Reports error.
     }
   }
 }
 
 
 void Parser::ParseTopLevelFunction(TopLevel* top_level) {
   TRACE_PARSER("ParseTopLevelFunction");
   AbstractType& result_type = Type::Handle(Type::DynamicType());
   const bool is_static = true;
+  bool is_external = false;
+  if (CurrentToken() == Token::kEXTERNAL) {
+    ConsumeToken();
+    is_external = true;
+  }
   if (CurrentToken() == Token::kVOID) {
     ConsumeToken();
     result_type = Type::VoidType();
   } else {
     // Parse optional type.
     if ((CurrentToken() == Token::kIDENT) &&
         (LookaheadToken(1) != Token::kLPAREN)) {
       result_type = ParseType(ClassFinalizer::kTryResolve);
     }
   }
@@ skipping 16 matching lines @@
 
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("'(' expected");
   }
   const intptr_t function_pos = TokenPos();
   ParamList params;
   const bool allow_explicit_default_values = true;
   ParseFormalParameterList(allow_explicit_default_values, &params);
 
   intptr_t function_end_pos = function_pos;
-  if (CurrentToken() == Token::kLBRACE) {
+  if (is_external) {
+    ExpectSemicolon();
+  } else if (CurrentToken() == Token::kLBRACE) {
     SkipBlock();
     function_end_pos = TokenPos();
   } else if (CurrentToken() == Token::kARROW) {
     ConsumeToken();
     SkipExpr();
     ExpectSemicolon();
     function_end_pos = TokenPos();
   } else if (IsLiteral("native")) {
     ParseNativeDeclaration();
   } else {
     ErrorMsg("function block expected");
   }
   Function& func = Function::Handle(
       Function::New(func_name, RawFunction::kRegularFunction,
-                    is_static, false, function_pos));
+                    is_static, false, is_external, function_pos));
   func.set_result_type(result_type);
   func.set_end_token_pos(function_end_pos);
   AddFormalParamsToFunction(&params, func);
   top_level->functions.Add(func);
   library_.AddObject(func, func_name);
 }
 
 
 void Parser::ParseTopLevelAccessor(TopLevel* top_level) {
   TRACE_PARSER("ParseTopLevelAccessor");
@@ skipping 61 matching lines @@
     ExpectSemicolon();
   } else if (IsLiteral("native")) {
     ParseNativeDeclaration();
   } else {
     ErrorMsg("function block expected");
   }
   Function& func = Function::Handle(
       Function::New(accessor_name,
                     is_getter? RawFunction::kGetterFunction :
                                RawFunction::kSetterFunction,
-                    is_static, false, accessor_pos));
+                    is_static, false, false, accessor_pos));
   func.set_result_type(result_type);
   AddFormalParamsToFunction(&params, func);
   top_level->functions.Add(func);
   library_.AddObject(func, accessor_name);
 }
 
 
 void Parser::ParseLibraryName() {
   TRACE_PARSER("ParseLibraryName");
   if ((script_.kind() == RawScript::kLibraryTag) &&
@@ skipping 825 matching lines @@
   }
   SetPosition(saved_pos);
   return is_var_decl;
 }
 
 
 // Look ahead to detect whether the next tokens should be parsed as
 // a function declaration. Token position remains unchanged.
 bool Parser::IsFunctionDeclaration() {
   const intptr_t saved_pos = TokenPos();
+  bool is_external = false;
+  if (is_top_level_ && (CurrentToken() == Token::kEXTERNAL)) {
+    // Skip over 'external' for top-level function declarations.
+    is_external = true;
+    ConsumeToken();
+  }
   if (IsIdentifier() && (LookaheadToken(1) == Token::kLPAREN)) {
     // Possibly a function without explicit return type.
     ConsumeToken();  // Consume function identifier.
   } else if (TryParseReturnType()) {
     if (!IsIdentifier()) {
       SetPosition(saved_pos);
       return false;
     }
     ConsumeToken();  // Consume function identifier.
   } else {
     SetPosition(saved_pos);
     return false;
   }
   // Check parameter list and the following token.
   if (CurrentToken() == Token::kLPAREN) {
     SkipToMatchingParenthesis();
     if ((CurrentToken() == Token::kLBRACE) ||
         (CurrentToken() == Token::kARROW) ||
-        (is_top_level_ && IsLiteral("native"))) {
+        (is_top_level_ && IsLiteral("native")) ||
+        (is_external && (CurrentToken() == Token::kSEMICOLON))) {

[hausner, 2012/07/30 16:22:41]

I don't think you need to check for the semicolon here. All this function needs
to do is checking tokens minimally until we know that we are looking at a
function declaration, not anything else. 

[Ivan Posva, 2012/07/30 22:33:33]

Done.

       SetPosition(saved_pos);
       return true;
     }
   }
   SetPosition(saved_pos);
   return false;
 }
 
 
 bool Parser::IsTopLevelAccessor() {
@@ skipping 4176 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart