Replace intptr_t with TokenDescriptor

runtime/vm/object_test.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 "platform/globals.h"
 
 #include "vm/assembler.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
@@ skipping 11 matching lines @@
 DECLARE_FLAG(bool, write_protect_code);
 
 static RawLibrary* CreateDummyLibrary(const String& library_name) {
   return Library::New(library_name);
 }
 
 
 static RawClass* CreateDummyClass(const String& class_name,
                                   const Script& script) {
   const Class& cls = Class::Handle(
-      Class::New(class_name, script, Token::kNoSourcePos));
+      Class::New(class_name, script, TokenDescriptor::kNoSource));
   cls.set_is_synthesized_class();  // Dummy class for testing.
   return cls.raw();
 }
 
 
 TEST_CASE(Class) {
   // Allocate the class first.
   const String& class_name = String::Handle(Symbols::New("MyClass"));
   const Script& script = Script::Handle();
   const Class& cls = Class::Handle(CreateDummyClass(class_name, script));
@@ skipping 18 matching lines @@
   // parsed.
   ClassFinalizer::FinalizeTypesInClass(cls);
 
   // Create and populate the function arrays.
   const Array& functions = Array::Handle(Array::New(6));
   Function& function = Function::Handle();
   String& function_name = String::Handle();
   function_name = Symbols::New("foo");
   function = Function::New(
       function_name, RawFunction::kRegularFunction,
-      false, false, false, false, false, cls, 0);
+      false, false, false, false, false, cls, TokenDescriptor::kMinSource);
   functions.SetAt(0, function);
   function_name = Symbols::New("bar");
   function = Function::New(
       function_name, RawFunction::kRegularFunction,
-      false, false, false, false, false, cls, 0);
+      false, false, false, false, false, cls, TokenDescriptor::kMinSource);
 
   const int kNumFixedParameters = 2;
   const int kNumOptionalParameters = 3;
   const bool kAreOptionalPositional = true;
   function.set_num_fixed_parameters(kNumFixedParameters);
   function.SetNumOptionalParameters(kNumOptionalParameters,
                                     kAreOptionalPositional);
   functions.SetAt(1, function);
 
   function_name = Symbols::New("baz");
   function = Function::New(
       function_name, RawFunction::kRegularFunction,
-      false, false, false, false, false, cls, 0);
+      false, false, false, false, false, cls, TokenDescriptor::kMinSource);
   functions.SetAt(2, function);
 
   function_name = Symbols::New("Foo");
   function = Function::New(
       function_name, RawFunction::kRegularFunction,
-      true, false, false, false, false, cls, 0);
+      true, false, false, false, false, cls, TokenDescriptor::kMinSource);
 
   functions.SetAt(3, function);
   function_name = Symbols::New("Bar");
   function = Function::New(
       function_name, RawFunction::kRegularFunction,
-      true, false, false, false, false, cls, 0);
+      true, false, false, false, false, cls, TokenDescriptor::kMinSource);
   functions.SetAt(4, function);
   function_name = Symbols::New("BaZ");
   function = Function::New(
       function_name, RawFunction::kRegularFunction,
-      true, false, false, false, false, cls, 0);
+      true, false, false, false, false, cls, TokenDescriptor::kMinSource);
   functions.SetAt(5, function);
 
   // Setup the functions in the class.
   cls.SetFunctions(functions);
 
   // The class can now be finalized.
   cls.Finalize();
 
   function_name = String::New("Foo");
   function = cls.LookupDynamicFunction(function_name);
@@ skipping 117 matching lines @@
   "  var baz = \"${foo('}')}\";\n"
   "}\n";
   Dart_Handle lib_h = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib_h);
   Library& lib = Library::Handle();
   lib ^= Api::UnwrapHandle(lib_h);
   EXPECT(!lib.IsNull());
   const Class& cls = Class::Handle(
       lib.LookupClass(String::Handle(String::New("A"))));
   EXPECT(!cls.IsNull());
-  const intptr_t end_token_pos = cls.ComputeEndTokenPos();
+  const TokenDescriptor end_token_pos = cls.ComputeEndTokenPos();
   const Script& scr = Script::Handle(cls.script());
   intptr_t line;
   intptr_t col;
   scr.GetTokenLocation(end_token_pos, &line, &col);
   EXPECT(line == 10 && col == 1);
 }
 
 
 TEST_CASE(InstanceClass) {
   // Allocate the class first.
@@ skipping 20 matching lines @@
   // No fields, functions, or super type for the OneFieldClass.
   EXPECT_EQ(Array::Handle(empty_class.fields()).Length(), 0);
   EXPECT_EQ(Array::Handle(empty_class.functions()).Length(), 0);
   EXPECT_EQ(empty_class.super_type(), AbstractType::null());
   ClassFinalizer::FinalizeTypesInClass(one_field_class);
 
   const Array& one_fields = Array::Handle(Array::New(1));
   const String& field_name = String::Handle(Symbols::New("the_field"));
   const Field& field = Field::Handle(
       Field::New(field_name, false, false, false, true, one_field_class,
-                 Object::dynamic_type(), 0));
+                 Object::dynamic_type(), TokenDescriptor::kMinSource));
   one_fields.SetAt(0, field);
   one_field_class.SetFields(one_fields);
   one_field_class.Finalize();
   intptr_t header_size = sizeof(RawObject);
   EXPECT_EQ(Utils::RoundUp((header_size + (1 * kWordSize)), kObjectAlignment),
             one_field_class.instance_size());
   EXPECT_EQ(header_size, field.Offset());
   EXPECT(!one_field_class.is_implemented());
   one_field_class.set_is_implemented();
   EXPECT(one_field_class.is_implemented());
@@ skipping 2159 matching lines @@
   str = script.GetLine(last_dart_line);
   EXPECT_STREQ("  }", str.ToCString());
 
   script.Tokenize(String::Handle(String::New("ABC")));
   // Tokens: 0: kIDENT, 1: kLPAREN, 2: kRPAREN, 3: kLBRACE, 4: kNEWLINE,
   //         5: kRETURN, 6: kSTRING, 7: kSEMICOLON, 8: kNEWLINE,
   //         9: kRBRACE, 10: kNEWLINE
 
   intptr_t line, col;
   intptr_t fast_line;
-  script.GetTokenLocation(0, &line, &col);
+  script.GetTokenLocation(TokenDescriptor(0), &line, &col);
   EXPECT_EQ(first_dart_line, line);
   EXPECT_EQ(col, col_offset + 1);
 
   // We allow asking for only the line number, which only scans the token stream
   // instead of rescanning the script.
-  script.GetTokenLocation(0, &fast_line, NULL);
+  script.GetTokenLocation(TokenDescriptor(0), &fast_line, NULL);
   EXPECT_EQ(line, fast_line);
 
-  script.GetTokenLocation(5, &line, &col);  // Token 'return'
+  script.GetTokenLocation(TokenDescriptor(5), &line, &col);  // Token 'return'
   EXPECT_EQ(4, line);  // 'return' is in line 4.
   EXPECT_EQ(5, col);   // Four spaces before 'return'.
 
   // We allow asking for only the line number, which only scans the token stream
   // instead of rescanning the script.
-  script.GetTokenLocation(5, &fast_line, NULL);
+  script.GetTokenLocation(TokenDescriptor(5), &fast_line, NULL);
   EXPECT_EQ(line, fast_line);
 
-  intptr_t first_idx, last_idx;
+  TokenDescriptor first_idx, last_idx;
   script.TokenRangeAtLine(3, &first_idx, &last_idx);
-  EXPECT_EQ(0, first_idx);  // Token 'main' is first token.
-  EXPECT_EQ(3, last_idx);   // Token { is last token.
+  EXPECT_EQ(0, first_idx.value());  // Token 'main' is first token.
+  EXPECT_EQ(3, last_idx.value());   // Token { is last token.
   script.TokenRangeAtLine(4, &first_idx, &last_idx);
-  EXPECT_EQ(5, first_idx);  // Token 'return' is first token.
-  EXPECT_EQ(7, last_idx);   // Token ; is last token.
+  EXPECT_EQ(5, first_idx.value());  // Token 'return' is first token.
+  EXPECT_EQ(7, last_idx.value());   // Token ; is last token.
   script.TokenRangeAtLine(5, &first_idx, &last_idx);
-  EXPECT_EQ(9, first_idx);  // Token } is first and only token.
-  EXPECT_EQ(9, last_idx);
+  EXPECT_EQ(9, first_idx.value());  // Token } is first and only token.
+  EXPECT_EQ(9, last_idx.value());
   script.TokenRangeAtLine(1, &first_idx, &last_idx);
-  EXPECT_EQ(0, first_idx);
-  EXPECT_EQ(3, last_idx);
+  EXPECT_EQ(0, first_idx.value());
+  EXPECT_EQ(3, last_idx.value());
   script.TokenRangeAtLine(6, &first_idx, &last_idx);
-  EXPECT_EQ(-1, first_idx);
-  EXPECT_EQ(-1, last_idx);
+  EXPECT_EQ(-1, first_idx.value());
+  EXPECT_EQ(-1, last_idx.value());
   script.TokenRangeAtLine(1000, &first_idx, &last_idx);
-  EXPECT_EQ(-1, first_idx);
-  EXPECT_EQ(-1, last_idx);
+  EXPECT_EQ(-1, first_idx.value());
+  EXPECT_EQ(-1, last_idx.value());
 }
 
 
 TEST_CASE(Context) {
   const int kNumVariables = 5;
   const Context& parent_context = Context::Handle(Context::New(0));
   const Context& context = Context::Handle(Context::New(kNumVariables));
   context.set_parent(parent_context);
   EXPECT_EQ(kNumVariables, context.num_variables());
   EXPECT(Context::Handle(context.parent()).raw() == parent_context.raw());
@@ skipping 18 matching lines @@
   LocalScope* parent_scope =
       new LocalScope(NULL, parent_scope_function_level, 0);
 
   const intptr_t local_scope_function_level = 1;
   LocalScope* local_scope =
       new LocalScope(parent_scope, local_scope_function_level, 0);
 
   const Type& dynamic_type = Type::ZoneHandle(Type::DynamicType());
   const String& a = String::ZoneHandle(Symbols::New("a"));
   LocalVariable* var_a =
-      new LocalVariable(Token::kNoSourcePos, a, dynamic_type);
+      new LocalVariable(TokenDescriptor::kNoSource, a, dynamic_type);
   parent_scope->AddVariable(var_a);
 
   const String& b = String::ZoneHandle(Symbols::New("b"));
   LocalVariable* var_b =
-      new LocalVariable(Token::kNoSourcePos, b, dynamic_type);
+      new LocalVariable(TokenDescriptor::kNoSource, b, dynamic_type);
   local_scope->AddVariable(var_b);
 
   const String& c = String::ZoneHandle(Symbols::New("c"));
   LocalVariable* var_c =
-      new LocalVariable(Token::kNoSourcePos, c, dynamic_type);
+      new LocalVariable(TokenDescriptor::kNoSource, c, dynamic_type);
   parent_scope->AddVariable(var_c);
 
   bool test_only = false;  // Please, insert alias.
   var_a = local_scope->LookupVariable(a, test_only);
   EXPECT(var_a->is_captured());
   EXPECT_EQ(parent_scope_function_level, var_a->owner()->function_level());
   EXPECT(local_scope->LocalLookupVariable(a) == var_a);  // Alias.
 
   var_b = local_scope->LookupVariable(b, test_only);
   EXPECT(!var_b->is_captured());
@@ skipping 55 matching lines @@
   // Allocate the class first.
   const String& class_name = String::Handle(Symbols::New("MyClass"));
   const Script& script = Script::Handle();
   const Class& cls = Class::Handle(CreateDummyClass(class_name, script));
   const Array& functions = Array::Handle(Array::New(1));
 
   const Context& context = Context::Handle(Context::New(0));
   Function& parent = Function::Handle();
   const String& parent_name = String::Handle(Symbols::New("foo_papa"));
   parent = Function::New(parent_name, RawFunction::kRegularFunction,
-                         false, false, false, false, false, cls, 0);
+                         false, false, false, false, false, cls,
+                         TokenDescriptor::kMinSource);
   functions.SetAt(0, parent);
   cls.SetFunctions(functions);
 
   Function& function = Function::Handle();
   const String& function_name = String::Handle(Symbols::New("foo"));
-  function = Function::NewClosureFunction(function_name, parent, 0);
+  function = Function::NewClosureFunction(
+      function_name, parent, TokenDescriptor::kMinSource);
   const Closure& closure = Closure::Handle(Closure::New(function, context));
   const Class& closure_class = Class::Handle(closure.clazz());
   EXPECT_EQ(closure_class.id(), kClosureCid);
   const Function& closure_function = Function::Handle(closure.function());
   EXPECT_EQ(closure_function.raw(), function.raw());
   const Context& closure_context = Context::Handle(closure.context());
   EXPECT_EQ(closure_context.raw(), context.raw());
 }
 
 
@@ skipping 42 matching lines @@
   const String& class_name = String::Handle(Symbols::New("ownerClass"));
   const String& lib_name = String::Handle(Symbols::New("ownerLibrary"));
   const Script& script = Script::Handle();
   const Class& owner_class =
       Class::Handle(CreateDummyClass(class_name, script));
   const Library& owner_library =
       Library::Handle(CreateDummyLibrary(lib_name));
   owner_class.set_library(owner_library);
   const String& function_name = String::ZoneHandle(Symbols::New(name));
   return Function::New(function_name, RawFunction::kRegularFunction,
-                       true, false, false, false, false, owner_class, 0);
+                       true, false, false, false, false, owner_class,
+                       TokenDescriptor::kMinSource);
 }
 
 
 // Test for Code and Instruction object creation.
 TEST_CASE(Code) {
   extern void GenerateIncrement(Assembler* assembler);
   Assembler _assembler_;
   GenerateIncrement(&_assembler_);
   const Function& function = Function::Handle(CreateFunction("Test_Code"));
   Code& code = Code::Handle(Code::FinalizeCode(function, &_assembler_));
@@ skipping 122 matching lines @@
   EXPECT_EQ(150u, handlers.HandlerPCOffset(3));
   EXPECT(!handlers.NeedsStacktrace(3));
   EXPECT(handlers.HasCatchAll(3));
 }
 
 
 TEST_CASE(PcDescriptors) {
   DescriptorList* builder = new DescriptorList(0);
 
   // kind, pc_offset, deopt_id, token_pos, try_index
-  builder->AddDescriptor(RawPcDescriptors::kOther, 10, 1, 20, 1);
-  builder->AddDescriptor(RawPcDescriptors::kDeopt, 20, 2, 30, 0);
-  builder->AddDescriptor(RawPcDescriptors::kOther, 30, 3, 40, 1);
-  builder->AddDescriptor(RawPcDescriptors::kOther, 10, 4, 40, 2);
-  builder->AddDescriptor(RawPcDescriptors::kOther, 10, 5, 80, 3);
-  builder->AddDescriptor(RawPcDescriptors::kOther, 80, 6, 150, 3);
+  builder->AddDescriptor(RawPcDescriptors::kOther,
+                         10, 1, TokenDescriptor(20), 1);
+  builder->AddDescriptor(RawPcDescriptors::kDeopt,
+                         20, 2, TokenDescriptor(30), 0);
+  builder->AddDescriptor(RawPcDescriptors::kOther,
+                         30, 3, TokenDescriptor(40), 1);
+  builder->AddDescriptor(RawPcDescriptors::kOther,
+                         10, 4, TokenDescriptor(40), 2);
+  builder->AddDescriptor(RawPcDescriptors::kOther,
+                         10, 5, TokenDescriptor(80), 3);
+  builder->AddDescriptor(RawPcDescriptors::kOther,
+                         80, 6, TokenDescriptor(150), 3);
 
   PcDescriptors& descriptors = PcDescriptors::Handle();
   descriptors ^= builder->FinalizePcDescriptors(0);
 
   extern void GenerateIncrement(Assembler* assembler);
   Assembler _assembler_;
   GenerateIncrement(&_assembler_);
   Code& code = Code::Handle(Code::FinalizeCode(
       Function::Handle(CreateFunction("Test_Code")), &_assembler_));
   code.set_pc_descriptors(descriptors);
 
   // Verify the PcDescriptor entries by accessing them.
   const PcDescriptors& pc_descs = PcDescriptors::Handle(code.pc_descriptors());
   PcDescriptors::Iterator iter(pc_descs, RawPcDescriptors::kAnyKind);
 
   EXPECT_EQ(true, iter.MoveNext());
-  EXPECT_EQ(20, iter.TokenPos());
+  EXPECT_EQ(20, iter.TokenPos().value());
   EXPECT_EQ(1, iter.TryIndex());
   EXPECT_EQ(static_cast<uword>(10), iter.PcOffset());
   EXPECT_EQ(1, iter.DeoptId());
   EXPECT_EQ(RawPcDescriptors::kOther, iter.Kind());
 
   EXPECT_EQ(true, iter.MoveNext());
-  EXPECT_EQ(30, iter.TokenPos());
+  EXPECT_EQ(30, iter.TokenPos().value());
   EXPECT_EQ(RawPcDescriptors::kDeopt, iter.Kind());
 
   EXPECT_EQ(true, iter.MoveNext());
-  EXPECT_EQ(40, iter.TokenPos());
+  EXPECT_EQ(40, iter.TokenPos().value());
 
   EXPECT_EQ(true, iter.MoveNext());
-  EXPECT_EQ(40, iter.TokenPos());
+  EXPECT_EQ(40, iter.TokenPos().value());
 
   EXPECT_EQ(true, iter.MoveNext());
-  EXPECT_EQ(80, iter.TokenPos());
+  EXPECT_EQ(80, iter.TokenPos().value());
 
   EXPECT_EQ(true, iter.MoveNext());
-  EXPECT_EQ(150, iter.TokenPos());
+  EXPECT_EQ(150, iter.TokenPos().value());
 
   EXPECT_EQ(3, iter.TryIndex());
   EXPECT_EQ(static_cast<uword>(80), iter.PcOffset());
-  EXPECT_EQ(150, iter.TokenPos());
+  EXPECT_EQ(150, iter.TokenPos().value());
   EXPECT_EQ(RawPcDescriptors::kOther, iter.Kind());
 
   EXPECT_EQ(false, iter.MoveNext());
 }
 
 
 TEST_CASE(PcDescriptorsLargeDeltas) {
   DescriptorList* builder = new DescriptorList(0);
 
   // kind, pc_offset, deopt_id, token_pos, try_index
-  builder->AddDescriptor(RawPcDescriptors::kOther, 100, 1, 200, 1);
-  builder->AddDescriptor(RawPcDescriptors::kDeopt, 200, 2, 300, 0);
-  builder->AddDescriptor(RawPcDescriptors::kOther, 300, 3, 400, 1);
-  builder->AddDescriptor(RawPcDescriptors::kOther, 100, 4, 0, 2);
-  builder->AddDescriptor(RawPcDescriptors::kOther, 100, 5, 800, 3);
-  builder->AddDescriptor(RawPcDescriptors::kOther, 800, 6, 150, 3);
+  builder->AddDescriptor(RawPcDescriptors::kOther,
+                         100, 1, TokenDescriptor(200), 1);
+  builder->AddDescriptor(RawPcDescriptors::kDeopt,
+                         200, 2, TokenDescriptor(300), 0);
+  builder->AddDescriptor(RawPcDescriptors::kOther,
+                         300, 3, TokenDescriptor(400), 1);
+  builder->AddDescriptor(RawPcDescriptors::kOther,
+                         100, 4, TokenDescriptor(0), 2);
+  builder->AddDescriptor(RawPcDescriptors::kOther,
+                         100, 5, TokenDescriptor(800), 3);
+  builder->AddDescriptor(RawPcDescriptors::kOther,
+                         800, 6, TokenDescriptor(150), 3);
 
   PcDescriptors& descriptors = PcDescriptors::Handle();
   descriptors ^= builder->FinalizePcDescriptors(0);
 
   extern void GenerateIncrement(Assembler* assembler);
   Assembler _assembler_;
   GenerateIncrement(&_assembler_);
   Code& code = Code::Handle(Code::FinalizeCode(
       Function::Handle(CreateFunction("Test_Code")), &_assembler_));
   code.set_pc_descriptors(descriptors);
 
   // Verify the PcDescriptor entries by accessing them.
   const PcDescriptors& pc_descs = PcDescriptors::Handle(code.pc_descriptors());
   PcDescriptors::Iterator iter(pc_descs, RawPcDescriptors::kAnyKind);
 
   EXPECT_EQ(true, iter.MoveNext());
-  EXPECT_EQ(200, iter.TokenPos());
+  EXPECT_EQ(200, iter.TokenPos().value());
   EXPECT_EQ(1, iter.TryIndex());
   EXPECT_EQ(static_cast<uword>(100), iter.PcOffset());
   EXPECT_EQ(1, iter.DeoptId());
   EXPECT_EQ(RawPcDescriptors::kOther, iter.Kind());
 
   EXPECT_EQ(true, iter.MoveNext());
-  EXPECT_EQ(300, iter.TokenPos());
+  EXPECT_EQ(300, iter.TokenPos().value());
   EXPECT_EQ(RawPcDescriptors::kDeopt, iter.Kind());
 
   EXPECT_EQ(true, iter.MoveNext());
-  EXPECT_EQ(400, iter.TokenPos());
+  EXPECT_EQ(400, iter.TokenPos().value());
 
   EXPECT_EQ(true, iter.MoveNext());
-  EXPECT_EQ(0, iter.TokenPos());
+  EXPECT_EQ(0, iter.TokenPos().value());
 
   EXPECT_EQ(true, iter.MoveNext());
-  EXPECT_EQ(800, iter.TokenPos());
+  EXPECT_EQ(800, iter.TokenPos().value());
 
   EXPECT_EQ(true, iter.MoveNext());
-  EXPECT_EQ(150, iter.TokenPos());
+  EXPECT_EQ(150, iter.TokenPos().value());
 
   EXPECT_EQ(3, iter.TryIndex());
   EXPECT_EQ(static_cast<uword>(800), iter.PcOffset());
-  EXPECT_EQ(150, iter.TokenPos());
+  EXPECT_EQ(150, iter.TokenPos().value());
   EXPECT_EQ(RawPcDescriptors::kOther, iter.Kind());
 
   EXPECT_EQ(false, iter.MoveNext());
 }
 
 
 static RawClass* CreateTestClass(const char* name) {
   const String& class_name = String::Handle(Symbols::New(name));
   const Class& cls = Class::Handle(
       CreateDummyClass(class_name, Script::Handle()));
   return cls.raw();
 }
 
 
 static RawField* CreateTestField(const char* name) {
   const Class& cls = Class::Handle(CreateTestClass("global:"));
   const String& field_name = String::Handle(Symbols::New(name));
   const Field& field =
       Field::Handle(Field::New(field_name, true, false, false, true, cls,
-          Object::dynamic_type(), 0));
+          Object::dynamic_type(), TokenDescriptor::kMinSource));
   return field.raw();
 }
 
 
 TEST_CASE(ClassDictionaryIterator) {
   Class& ae66 = Class::ZoneHandle(CreateTestClass("Ae6/6"));
   Class& re44 = Class::ZoneHandle(CreateTestClass("Re4/4"));
   Field& ce68 = Field::ZoneHandle(CreateTestField("Ce6/8"));
   Field& tee = Field::ZoneHandle(CreateTestField("TEE"));
   String& url = String::ZoneHandle(String::New("SBB"));
@@ skipping 24 matching lines @@
   const bool is_external = false;
   const bool is_native = false;
   return Function::New(function_name,
                        RawFunction::kRegularFunction,
                        is_static,
                        is_const,
                        is_abstract,
                        is_external,
                        is_native,
                        cls,
-                       0);
+                       TokenDescriptor::kMinSource);
 }
 
 
 TEST_CASE(ICData) {
   Function& function = Function::Handle(GetDummyTarget("Bern"));
   const intptr_t id = 12;
   const intptr_t num_args_tested = 1;
   const String& target_name = String::Handle(Symbols::New("Thun"));
   const Array& args_descriptor =
       Array::Handle(ArgumentsDescriptor::New(1, Object::null_array()));
@@ skipping 753 matching lines @@
   // Allocate the class first.
   const String& class_name = String::Handle(Symbols::New("MyClass"));
   const Script& script = Script::Handle();
   const Class& cls = Class::Handle(CreateDummyClass(class_name, script));
   const Array& functions = Array::Handle(Array::New(1));
   const Isolate* iso = Isolate::Current();
 
   Function& parent = Function::Handle();
   const String& parent_name = String::Handle(Symbols::New("foo_papa"));
   parent = Function::New(parent_name, RawFunction::kRegularFunction,
-                         false, false, false, false, false, cls, 0);
+                         false, false, false, false, false, cls,
+                         TokenDescriptor::kMinSource);
   functions.SetAt(0, parent);
   cls.SetFunctions(functions);
 
   Function& function = Function::Handle();
   const String& function_name = String::Handle(Symbols::New("foo"));
-  function = Function::NewClosureFunction(function_name, parent, 0);
+  function = Function::NewClosureFunction(function_name, parent,
+                                          TokenDescriptor::kMinSource);
   // Add closure function to class.
   iso->AddClosureFunction(function);
 
   // The closure should return a valid index.
   intptr_t good_closure_index = iso->FindClosureIndex(function);
   EXPECT_GE(good_closure_index, 0);
   // The parent function should return an invalid index.
   intptr_t bad_closure_index = iso->FindClosureIndex(parent);
   EXPECT_EQ(bad_closure_index, -1);
 
   // Retrieve closure function via index.
   Function& func_from_index = Function::Handle();
   func_from_index ^= iso->ClosureFunctionFromIndex(good_closure_index);
   // Same closure function.
   EXPECT_EQ(func_from_index.raw(), function.raw());
 }
 
 
 TEST_CASE(FindInvocationDispatcherFunctionIndex) {
   const String& class_name = String::Handle(Symbols::New("MyClass"));
   const Script& script = Script::Handle();
   const Class& cls = Class::Handle(CreateDummyClass(class_name, script));
   ClassFinalizer::FinalizeTypesInClass(cls);
 
   const Array& functions = Array::Handle(Array::New(1));
   Function& parent = Function::Handle();
   const String& parent_name = String::Handle(Symbols::New("foo_papa"));
   parent = Function::New(parent_name, RawFunction::kRegularFunction,
-                         false, false, false, false, false, cls, 0);
+                         false, false, false, false, false, cls,
+                         TokenDescriptor::kMinSource);
   functions.SetAt(0, parent);
   cls.SetFunctions(functions);
   cls.Finalize();
 
   // Add invocation dispatcher.
   const String& invocation_dispatcher_name =
       String::Handle(Symbols::New("myMethod"));
   const Array& args_desc = Array::Handle(ArgumentsDescriptor::New(1));
   Function& invocation_dispatcher = Function::Handle();
   invocation_dispatcher ^=
@@ skipping 852 matching lines @@
   String& test = String::Handle();
   String& result = String::Handle();
   for (size_t i = 0; i < ARRAY_SIZE(tests); i++) {
     test = String::New(tests[i].in);
     result = String::IdentifierPrettyName(test);
     EXPECT_STREQ(tests[i].out, result.ToCString());
   }
 }
 
 }  // namespace dart