Replace intptr_t with TokenDescriptor

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 270 matching lines @@
 
   // Append a 'diamond' branch and join to this graph, depending on which
   // parts are reachable.  Assumes this graph is open.
   void Join(const TestGraphVisitor& test_fragment,
             const EffectGraphVisitor& true_fragment,
             const EffectGraphVisitor& false_fragment);
 
   // Append a 'while loop' test and back edge to this graph, depending on
   // which parts are reachable.  Afterward, the graph exit is the false
   // successor of the loop condition.
-  void TieLoop(intptr_t token_pos,
+  void TieLoop(TokenPosition token_pos,
                const TestGraphVisitor& test_fragment,
                const EffectGraphVisitor& body_fragment,
                const EffectGraphVisitor& test_preamble_fragment);
 
   // 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);
+  void AddReturnExit(TokenPosition token_pos, Value* value);
 
  protected:
   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);
+                             TokenPosition token_pos);
+  Definition* BuildStoreExprTemp(Value* value, TokenPosition token_pos);
+  Definition* BuildLoadExprTemp(TokenPosition token_pos);
 
   Definition* BuildStoreLocal(const LocalVariable& local,
                               Value* value,
-                              intptr_t token_pos);
+                              TokenPosition token_pos);
   Definition* BuildLoadLocal(const LocalVariable& local,
-                             intptr_t token_pos);
-  LoadLocalInstr* BuildLoadThisVar(LocalScope* scope, intptr_t token_pos);
+                             TokenPosition token_pos);
+  LoadLocalInstr* BuildLoadThisVar(LocalScope* scope,
+                                   TokenPosition 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,
+      TokenPosition token_pos,
       const TypeArguments& type_arguments);
 
   void BuildTypecheckPushArguments(
-      intptr_t token_pos,
+      TokenPosition token_pos,
       PushArgumentInstr** push_instantiator_type_arguments);
-  void BuildTypecheckArguments(intptr_t token_pos,
+  void BuildTypecheckArguments(TokenPosition token_pos,
                                Value** instantiator_type_arguments);
-  Value* BuildInstantiator(intptr_t token_pos);
-  Value* BuildInstantiatorTypeArguments(intptr_t token_pos,
+  Value* BuildInstantiator(TokenPosition token_pos);
+  Value* BuildInstantiatorTypeArguments(TokenPosition token_pos,
                                         const Class& instantiator_class,
                                         Value* instantiator);
 
   // Perform a type check on the given value.
-  AssertAssignableInstr* BuildAssertAssignable(intptr_t token_pos,
+  AssertAssignableInstr* BuildAssertAssignable(TokenPosition token_pos,
                                                Value* value,
                                                const AbstractType& dst_type,
                                                const String& dst_name);
 
   // Perform a type check on the given value and return it.
-  Value* BuildAssignableValue(intptr_t token_pos,
+  Value* BuildAssignableValue(TokenPosition token_pos,
                               Value* value,
                               const AbstractType& dst_type,
                               const String& dst_name);
 
   static const bool kResultNeeded = true;
   static const bool kResultNotNeeded = false;
 
   Definition* BuildStoreIndexedValues(StoreIndexedNode* node,
                                       bool result_is_needed);
 
   void BuildInstanceSetterArguments(
       InstanceSetterNode* node,
       ZoneGrowableArray<PushArgumentInstr*>* arguments,
       bool result_is_needed);
 
   StrictCompareInstr* BuildStrictCompare(AstNode* left,
                                          AstNode* right,
                                          Token::Kind kind,
-                                         intptr_t token_pos);
+                                         TokenPosition token_pos);
 
   virtual void BuildTypeTest(ComparisonNode* node);
   virtual void BuildTypeCast(ComparisonNode* node);
 
   bool HasContextScope() const;
 
   // Moves the nth parent context into the context register.
   void UnchainContexts(intptr_t n);
 
   // Unchain the current context until its level matches the context level
   // expected on entry at the target specified by its scope.
   void AdjustContextLevel(LocalScope* target_scope);
 
   void CloseFragment() { exit_ = NULL; }
 
   // Returns a local variable index for a temporary local that is
   // on top of the current expression stack.
   intptr_t GetCurrentTempLocalIndex() const;
 
   Value* BuildObjectAllocation(ConstructorCallNode* node);
   void BuildConstructorCall(ConstructorCallNode* node,
                             PushArgumentInstr* alloc_value);
 
   void BuildSaveContext(const LocalVariable& variable,
-                        intptr_t token_pos);
+                        TokenPosition token_pos);
   void BuildRestoreContext(const LocalVariable& variable,
-                           intptr_t token_pos);
+                           TokenPosition token_pos);
 
-  Definition* BuildStoreContext(Value* value, intptr_t token_pos);
-  Definition* BuildCurrentContext(intptr_t token_pos);
+  Definition* BuildStoreContext(Value* value, TokenPosition token_pos);
+  Definition* BuildCurrentContext(TokenPosition token_pos);
 
   void BuildThrowNode(ThrowNode* node);
 
   StaticCallInstr* BuildStaticNoSuchMethodCall(
       const Class& target_class,
       AstNode* receiver,
       const String& method_name,
       ArgumentListNode* method_arguments,
       bool save_last_arg,
       bool is_super_invocation);
 
   StaticCallInstr* BuildThrowNoSuchMethodError(
-      intptr_t token_pos,
+      TokenPosition token_pos,
       const Class& function_class,
       const String& function_name,
       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);
+                                    TokenPosition token_pos);
 
   void BuildClosureCall(ClosureCallNode* node, bool result_needed);
 
-  Value* BuildNullValue(intptr_t token_pos);
+  Value* BuildNullValue(TokenPosition token_pos);
 
   // Returns true if the run-time type check can be eliminated.
-  bool CanSkipTypeCheck(intptr_t token_pos,
+  bool CanSkipTypeCheck(TokenPosition 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, intptr_t token_pos);
-  Definition* ExitTempLocalScope(LocalVariable* var, intptr_t token_pos);
+  LocalVariable* EnterTempLocalScope(Value* value, TokenPosition token_pos);
+  Definition* ExitTempLocalScope(LocalVariable* var, TokenPosition 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 83 matching lines @@
 //   - Neither NULL: true and false successors at the given addresses
 //
 // We expect that AstNode in test contexts either have only nonlocal exits
 // or else control flow has both true and false successors.
 //
 // The cis and token_pos are used in checked mode to verify that the
 // condition of the test is of type bool.
 class TestGraphVisitor : public ValueGraphVisitor {
  public:
   TestGraphVisitor(FlowGraphBuilder* owner,
-                   intptr_t condition_token_pos)
+                   TokenPosition condition_token_pos)
       : ValueGraphVisitor(owner),
         true_successor_addresses_(1),
         false_successor_addresses_(1),
         condition_token_pos_(condition_token_pos) { }
 
   void IfFalseGoto(JoinEntryInstr* join) const;
   void IfTrueGoto(JoinEntryInstr* join) const;
 
   BlockEntryInstr* CreateTrueSuccessor() const;
   BlockEntryInstr* CreateFalseSuccessor() const;
 
   virtual void VisitBinaryOpNode(BinaryOpNode* node);
 
-  intptr_t condition_token_pos() const { return condition_token_pos_; }
+  TokenPosition condition_token_pos() const { return condition_token_pos_; }
 
  private:
   // Construct and concatenate a Branch instruction to this graph fragment.
   // Closes the fragment and sets the output parameters.
   virtual void ReturnValue(Value* value);
 
   // Either merges the definition into a BranchInstr (Comparison, BooleanNegate)
   // or adds the definition to the graph and returns a use of its value.
   virtual void ReturnDefinition(Definition* definition);
 
   void MergeBranchWithComparison(ComparisonInstr* comp);
   void MergeBranchWithNegate(BooleanNegateInstr* comp);
 
   BlockEntryInstr* CreateSuccessorFor(
     const GrowableArray<TargetEntryInstr**>& branches) const;
 
   void ConnectBranchesTo(
     const GrowableArray<TargetEntryInstr**>& branches,
     JoinEntryInstr* join) const;
 
   // Output parameters.
   GrowableArray<TargetEntryInstr**> true_successor_addresses_;
   GrowableArray<TargetEntryInstr**> false_successor_addresses_;
 
-  intptr_t condition_token_pos_;
+  TokenPosition condition_token_pos_;
 };
 
 }  // namespace dart
 
 #endif  // VM_FLOW_GRAPH_BUILDER_H_