Set breakpoint at url, line number

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 2051 matching lines @@
       }
       SkipToMatchingParenthesis();
     } else {
       SkipInitializers();
     }
   }
 
   // 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->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,
                "function body not allowed in interface declaration");
     }
     if (CurrentToken() == Token::kLBRACE) {
       SkipBlock();
     } else {
       ConsumeToken();
       SkipExpr();
       ExpectSemicolon();
     }
+    method_end_pos = token_index_;
   } else if (IsLiteral("native")) {
     if (method->has_abstract) {
       ErrorMsg(method->name_pos,
                "abstract method '%s' may not have function body",
                method->name->ToCString());
     } else if (members->is_interface()) {
       ErrorMsg(method->name_pos,
                "function body not allowed in interface declaration");
     } else if (method->IsConstructor() && method->has_const) {
       ErrorMsg(method->name_pos,
@@ skipping 37 matching lines @@
   } else {
     function_kind = RawFunction::kFunction;
   }
   Function& func = Function::ZoneHandle(
       Function::New(*method->name,
                     function_kind,
                     method->has_static,
                     method->has_const,
                     method_pos));
   func.set_result_type(*method->type);
+  func.set_end_token_index(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) {
   // The parser has read the first field name and is now at the token
@@ skipping 961 matching lines @@
   }
 
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("'(' expected");
   }
   const intptr_t function_pos = token_index_;
   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) {
     SkipBlock();
+    function_end_pos = token_index_;
   } else if (CurrentToken() == Token::kARROW) {
     ConsumeToken();
     SkipExpr();
     ExpectSemicolon();
+    function_end_pos = token_index_;
   } else if (IsLiteral("native")) {
     ParseNativeDeclaration();
   } else {
     ErrorMsg("function block expected");
   }
   Function& func = Function::ZoneHandle(
       Function::New(func_name, RawFunction::kFunction,
                     is_static, false, function_pos));
   func.set_result_type(result_type);
+  func.set_end_token_index(function_end_pos);
   AddFormalParamsToFunction(&params, func);
   top_level->functions.Add(&func);
   library_.AddObject(func, func_name);
 }
 
 
 void Parser::ParseTopLevelAccessor(TopLevel* top_level) {
   const bool is_static = true;
   AbstractType& result_type = AbstractType::Handle();
   bool is_getter = (CurrentToken() == Token::kGET);
@@ skipping 4579 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart