Source positions for constructors and lots of async machinery

runtime/vm/flow_graph_builder.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_FLOW_GRAPH_BUILDER_H_
 #define VM_FLOW_GRAPH_BUILDER_H_
 
 #include "platform/assert.h"
 #include "platform/globals.h"
 #include "vm/allocation.h"
@@ skipping 285 matching lines @@
   // Wraps a value in a push-argument instruction and adds the result to the
   // graph.
   PushArgumentInstr* PushArgument(Value* value);
 
   // This implementation shares state among visitors by using the builder.
   // The implementation is incorrect if a visitor that hits a return is not
   // actually added to the graph.
   void AddReturnExit(intptr_t token_pos, Value* value);
 
  protected:
-  Definition* BuildStoreTemp(const LocalVariable& local, Value* value);
-  Definition* BuildStoreExprTemp(Value* value);
-  Definition* BuildLoadExprTemp();
+  Definition* BuildStoreTemp(const LocalVariable& local,
+                             Value* value,
+                             intptr_t token_pos);
+  Definition* BuildStoreExprTemp(Value* value, intptr_t token_pos);
+  Definition* BuildLoadExprTemp(intptr_t token_pos);
 
   Definition* BuildStoreLocal(const LocalVariable& local,
                               Value* value,
-                              intptr_t token_pos = Scanner::kNoSourcePos);
+                              intptr_t token_pos);
   Definition* BuildLoadLocal(const LocalVariable& local,
-                             intptr_t token_pos = Scanner::kNoSourcePos);
-  LoadLocalInstr* BuildLoadThisVar(LocalScope* scope);
+                             intptr_t token_pos);
+  LoadLocalInstr* BuildLoadThisVar(LocalScope* scope, intptr_t token_pos);
   LoadFieldInstr* BuildNativeGetter(
       NativeBodyNode* node,
       MethodRecognizer::Kind kind,
       intptr_t offset,
       const Type& type,
       intptr_t class_id);
   // Assumes setter parameter is named 'value'. Returns null constant.
   ConstantInstr* DoNativeSetterStoreValue(
       NativeBodyNode* node,
       intptr_t offset,
       StoreBarrierType emit_store_barrier);
 
   // Helpers for translating parts of the AST.
   void BuildPushArguments(const ArgumentListNode& node,
                           ZoneGrowableArray<PushArgumentInstr*>* values);
 
   // Creates an instantiated type argument vector used in preparation of an
   // allocation call.
   // May be called only if allocating an object of a parameterized class.
   Value* BuildInstantiatedTypeArguments(
       intptr_t token_pos,
       const TypeArguments& type_arguments);
 
   void BuildTypecheckPushArguments(
       intptr_t token_pos,
       PushArgumentInstr** push_instantiator_type_arguments);
   void BuildTypecheckArguments(intptr_t token_pos,
                                Value** instantiator_type_arguments);
-  Value* BuildInstantiator(const Class& instantiator_class);
+  Value* BuildInstantiator(intptr_t token_pos, const Class& instantiator_class);
   Value* BuildInstantiatorTypeArguments(intptr_t token_pos,
                                         const Class& instantiator_class,
                                         Value* instantiator);
 
   // Perform a type check on the given value.
   AssertAssignableInstr* BuildAssertAssignable(intptr_t token_pos,
                                                Value* value,
                                                const AbstractType& dst_type,
                                                const String& dst_name);
 
@@ skipping 66 matching lines @@
       ArgumentListNode* function_arguments,
       int invocation_type);
 
   void BuildStaticSetter(StaticSetterNode* node, bool result_is_needed);
   Definition* BuildStoreStaticField(StoreStaticFieldNode* node,
                                     bool result_is_needed,
                                     intptr_t token_pos);
 
   void BuildClosureCall(ClosureCallNode* node, bool result_needed);
 
-  Value* BuildNullValue();
+  Value* BuildNullValue(intptr_t token_pos);
 
   // Returns true if the run-time type check can be eliminated.
   bool CanSkipTypeCheck(intptr_t token_pos,
                         Value* value,
                         const AbstractType& dst_type,
                         const String& dst_name);
 
   // Helpers for allocating and deallocating temporary locals on top of the
   // expression stack.
-  LocalVariable* EnterTempLocalScope(Value* value);
-  Definition* ExitTempLocalScope(LocalVariable* var);
+  LocalVariable* EnterTempLocalScope(Value* value, intptr_t token_pos);
+  Definition* ExitTempLocalScope(LocalVariable* var, intptr_t token_pos);
 
   void BuildLetTempExpressions(LetNode* node);
 
   void BuildInstanceGetterConditional(InstanceGetterNode* node);
   void BuildInstanceCallConditional(InstanceCallNode* node);
 
   Thread* thread() const { return owner()->thread(); }
   Isolate* isolate() const { return owner()->isolate(); }
   Zone* zone() const { return owner()->zone(); }
 
@@ skipping 128 matching lines @@
   // Output parameters.
   GrowableArray<TargetEntryInstr**> true_successor_addresses_;
   GrowableArray<TargetEntryInstr**> false_successor_addresses_;
 
   intptr_t condition_token_pos_;
 };
 
 }  // namespace dart
 
 #endif  // VM_FLOW_GRAPH_BUILDER_H_