Expose set_source service command for functions

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 "platform/utils.h"
 #include "vm/ast_transformer.h"
 #include "vm/bootstrap.h"
@@ skipping 1088 matching lines @@
   if (parsed_function->has_finally_return_temp_var()) {
     body->scope()->AddVariable(parsed_function->finally_return_temp_var());
   }
   // The instantiator is not required in a static expression.
   ASSERT(!parser.IsInstantiatorRequired());
 
   return parsed_function;
 }
 
 
+RawObject* Parser::ParseFunctionFromSource(const Class& owning_class,
+                                           const String& source) {
+  Isolate* isolate = Isolate::Current();
+  StackZone zone(isolate);
+  LongJumpScope jump;
+  if (setjmp(*jump.Set()) == 0) {
+    const String& uri = String::Handle(Symbols::New("dynamically-added"));
+    const Script& script = Script::Handle(
+        Script::New(uri, source, RawScript::kSourceTag));
+    const Library& owning_library = Library::Handle(owning_class.library());
+    const String& private_key = String::Handle(owning_library.private_key());
+    script.Tokenize(private_key);
+    const intptr_t token_pos = 0;
+    Parser parser(script, owning_library, token_pos);
+    parser.is_top_level_ = true;
+    parser.set_current_class(owning_class);
+    const String& class_name = String::Handle(owning_class.Name());
+    ClassDesc members(owning_class, class_name, false, token_pos);
+    const intptr_t metadata_pos = parser.SkipMetadata();
+    parser.ParseClassMemberDefinition(&members, metadata_pos);
+    ASSERT(members.functions().Length() == 1);

[rmacnak, 2014/12/04 23:28:04]

Actually, make this return an error: a user could submit a field definition
instead of a method.

[Cutch, 2014/12/04 23:31:45]

Done.

+    const Function& func =
+        Function::ZoneHandle(Function::RawCast(members.functions().At(0)));
+    func.set_eval_script(script);
+    ParsedFunction* parsed_function = new ParsedFunction(isolate, func);
+    Parser::ParseFunction(parsed_function);
+    return func.raw();
+  } else {
+    const Error& error = Error::Handle(isolate->object_store()->sticky_error());
+    isolate->object_store()->clear_sticky_error();
+    return error.raw();
+  }
+  UNREACHABLE();
+}
+
+
 SequenceNode* Parser::ParseStaticFinalGetter(const Function& func) {
   TRACE_PARSER("ParseStaticFinalGetter");
   ParamList params;
   ASSERT(func.num_fixed_parameters() == 0);  // static.
   ASSERT(!func.HasOptionalParameters());
   ASSERT(AbstractType::Handle(I, func.result_type()).IsResolved());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
@@ skipping 2175 matching lines @@
   ASSERT(CurrentToken() == Token::kPERIOD);  // We checked above.
   ConsumeToken();
   return prefix.raw();
 }
 
 
 void Parser::ParseMethodOrConstructor(ClassDesc* members, MemberDesc* method) {
   TRACE_PARSER("ParseMethodOrConstructor");
   ASSERT(CurrentToken() == Token::kLPAREN || method->IsGetter());
   ASSERT(method->type != NULL);
-  ASSERT(method->name_pos > 0);
+  ASSERT(is_top_level_ || method->name_pos > 0);
   ASSERT(current_member_ == method);
 
   if (method->has_var) {
     ReportError(method->name_pos, "keyword var not allowed for methods");
   }
   if (method->has_final) {
     ReportError(method->name_pos, "'final' not allowed for methods");
   }
   if (method->has_abstract && method->has_static) {
     ReportError(method->name_pos,
@@ skipping 8851 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart