Replace intptr_t with TokenDescriptor

runtime/vm/source_report.cc

 // Copyright (c) 2015, 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/source_report.h"
 
 #include "vm/compiler.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 
 namespace dart {
 
 SourceReport::SourceReport(intptr_t report_set, CompileMode compile_mode)
     : report_set_(report_set),
       compile_mode_(compile_mode),
       thread_(NULL),
       script_(NULL),
-      start_pos_(-1),
-      end_pos_(-1),
+      start_pos_(TokenPosition::kNoSource),
+      end_pos_(TokenPosition::kNoSource),
       next_script_index_(0) {
 }
 
 
 void SourceReport::Init(Thread* thread,
                         const Script* script,
-                        intptr_t start_pos,
-                        intptr_t end_pos) {
+                        TokenPosition start_pos,
+                        TokenPosition end_pos) {
   thread_ = thread;
   script_ = script;
   start_pos_ = start_pos;
   end_pos_ = end_pos;
   script_table_entries_.Clear();
   script_table_.Clear();
   next_script_index_ = 0;
 }
 
 
 bool SourceReport::IsReportRequested(ReportKind report_kind) {
   return (report_set_ & report_kind) != 0;
 }
 
 
 bool SourceReport::ShouldSkipFunction(const Function& func) {
   if (script_ != NULL && !script_->IsNull()) {
     if (func.script() != script_->raw()) {
       // The function is from the wrong script.
       return true;
     }
-    if (((start_pos_ > 0) && (func.end_token_pos() < start_pos_)) ||
-        ((end_pos_ > 0) && (func.token_pos() > end_pos_))) {
+    if (((start_pos_ > TokenPosition::kMinSource) &&
+         (func.end_token_pos() < start_pos_)) ||
+        ((end_pos_ > TokenPosition::kMinSource) &&
+         (func.token_pos() > end_pos_))) {
       // The function does not intersect with the requested token range.
       return true;
     }
   }
 
   switch (func.kind()) {
     case RawFunction::kRegularFunction:
     case RawFunction::kClosureFunction:
     case RawFunction::kGetterFunction:
     case RawFunction::kSetterFunction:
@@ skipping 43 matching lines @@
       return true;
     }
   }
   return false;
 }
 
 
 void SourceReport::PrintCallSitesData(JSONObject* jsobj,
                                       const Function& func,
                                       const Code& code) {
-  const intptr_t begin_pos = func.token_pos();
-  const intptr_t end_pos = func.end_token_pos();
+  const TokenPosition begin_pos = func.token_pos();
+  const TokenPosition end_pos = func.end_token_pos();
 
   ZoneGrowableArray<const ICData*>* ic_data_array =
       new(zone()) ZoneGrowableArray<const ICData*>();
   func.RestoreICDataMap(ic_data_array, false /* clone descriptors */);
   const PcDescriptors& descriptors = PcDescriptors::Handle(
       zone(), code.pc_descriptors());
 
   JSONArray sites(jsobj, "callSites");
 
   PcDescriptors::Iterator iter(
       descriptors,
       RawPcDescriptors::kIcCall | RawPcDescriptors::kUnoptStaticCall);
   while (iter.MoveNext()) {
     HANDLESCOPE(thread());
     const ICData* ic_data = (*ic_data_array)[iter.DeoptId()];
     if (!ic_data->IsNull()) {
-      const intptr_t token_pos = iter.TokenPos();
+      const TokenPosition token_pos = iter.TokenPos();
       if ((token_pos < begin_pos) || (token_pos > end_pos)) {
         // Does not correspond to a valid source position.
         continue;
       }
       bool is_static_call = iter.Kind() == RawPcDescriptors::kUnoptStaticCall;
       ic_data->PrintToJSONArrayNew(sites, token_pos, is_static_call);
     }
   }
 }
 
 void SourceReport::PrintCoverageData(JSONObject* jsobj,
                                      const Function& func,
                                      const Code& code) {
-  const intptr_t begin_pos = func.token_pos();
-  const intptr_t end_pos = func.end_token_pos();
+  const TokenPosition begin_pos = func.token_pos();
+  const TokenPosition end_pos = func.end_token_pos();
 
   ZoneGrowableArray<const ICData*>* ic_data_array =
       new(zone()) ZoneGrowableArray<const ICData*>();
   func.RestoreICDataMap(ic_data_array, false /* clone descriptors */);
   const PcDescriptors& descriptors = PcDescriptors::Handle(
       zone(), code.pc_descriptors());
 
   const int kCoverageNone = 0;
   const int kCoverageMiss = 1;
   const int kCoverageHit = 2;
 
-  intptr_t func_length = (end_pos - begin_pos) + 1;
+  intptr_t func_length = (end_pos.Pos() - begin_pos.Pos()) + 1;
   GrowableArray<char> coverage(func_length);
   coverage.SetLength(func_length);
   for (int i = 0; i < func_length; i++) {
     coverage[i] = kCoverageNone;
   }
 
   PcDescriptors::Iterator iter(
       descriptors,
       RawPcDescriptors::kIcCall | RawPcDescriptors::kUnoptStaticCall);
   while (iter.MoveNext()) {
     HANDLESCOPE(thread());
     const ICData* ic_data = (*ic_data_array)[iter.DeoptId()];
     if (!ic_data->IsNull()) {
-      const intptr_t token_pos = iter.TokenPos();
+      const TokenPosition token_pos = iter.TokenPos();
       if ((token_pos < begin_pos) || (token_pos > end_pos)) {
         // Does not correspond to a valid source position.
         continue;
       }
       intptr_t count = ic_data->AggregateCount();
-      intptr_t token_offset = token_pos - begin_pos;
+      intptr_t token_offset = token_pos.Pos() - begin_pos.Pos();
       if (count > 0) {
         coverage[token_offset] = kCoverageHit;
       } else {
         if (coverage[token_offset] == kCoverageNone) {
           coverage[token_offset] = kCoverageMiss;
         }
       }
     }
   }
 
   JSONObject cov(jsobj, "coverage");
   {
     JSONArray hits(&cov, "hits");
     for (int i = 0; i < func_length; i++) {
       if (coverage[i] == kCoverageHit) {
-        hits.AddValue(begin_pos + i);  // Add the token position of the hit.
+        // Add the token position of the hit.
+        hits.AddValue(begin_pos.Pos() + i);
       }
     }
   }
   {
     JSONArray misses(&cov, "misses");
     for (int i = 0; i < func_length; i++) {
       if (coverage[i] == kCoverageMiss) {
-        misses.AddValue(begin_pos + i);  // Add the token position of the miss.
+        // Add the token position of the miss.
+        misses.AddValue(begin_pos.Pos() + i);
       }
     }
   }
 }
 
 void SourceReport::PrintPossibleBreakpointsData(JSONObject* jsobj,
                                                 const Function& func,
                                                 const Code& code) {
   const uint8_t kSafepointKind = (RawPcDescriptors::kIcCall |
                                   RawPcDescriptors::kUnoptStaticCall |
                                   RawPcDescriptors::kRuntimeCall);
-  const intptr_t begin_pos = func.token_pos();
-  const intptr_t end_pos = func.end_token_pos();
+  const TokenPosition begin_pos = func.token_pos();
+  const TokenPosition end_pos = func.end_token_pos();
 
   const PcDescriptors& descriptors = PcDescriptors::Handle(
       zone(), code.pc_descriptors());
 
-  intptr_t func_length = (end_pos - begin_pos) + 1;
+  intptr_t func_length = (end_pos.Pos() - begin_pos.Pos()) + 1;
   GrowableArray<char> possible(func_length);
   possible.SetLength(func_length);
   for (int i = 0; i < func_length; i++) {
     possible[i] = false;
   }
 
   PcDescriptors::Iterator iter(descriptors, kSafepointKind);
   while (iter.MoveNext()) {
-    const intptr_t token_pos = iter.TokenPos();
+    const TokenPosition token_pos = iter.TokenPos();
     if ((token_pos < begin_pos) || (token_pos > end_pos)) {
       // Does not correspond to a valid source position.
       continue;
     }
-    intptr_t token_offset = token_pos - begin_pos;
+    intptr_t token_offset = token_pos.Pos() - begin_pos.Pos();
     possible[token_offset] = true;
   }
 
   JSONArray bpts(jsobj, "possibleBreakpoints");
   for (int i = 0; i < func_length; i++) {
     if (possible[i]) {
-      bpts.AddValue(begin_pos + i);  // Add the token position.
+      // Add the token position.
+      bpts.AddValue(begin_pos.Pos() + i);
     }
   }
 }
 
 
 void SourceReport::PrintScriptTable(JSONArray* scripts) {
   for (int i = 0; i < script_table_entries_.length(); i++) {
     const Script* script = script_table_entries_[i].script;
     scripts->AddValue(*script);
   }
 }
 
 
 void SourceReport::VisitFunction(JSONArray* jsarr, const Function& func) {
   if (ShouldSkipFunction(func)) {
     return;
   }
 
   const Script& script = Script::Handle(zone(), func.script());
-  const intptr_t begin_pos = func.token_pos();
-  const intptr_t end_pos = func.end_token_pos();
+  const TokenPosition begin_pos = func.token_pos();
+  const TokenPosition end_pos = func.end_token_pos();
 
   Code& code = Code::Handle(zone(), func.unoptimized_code());
   if (code.IsNull()) {
     if (func.HasCode() || (compile_mode_ == kForceCompile)) {
       if (Compiler::EnsureUnoptimizedCode(thread(), func) != Error::null()) {
         // Ignore the error and this function entirely.
         return;
       }
       code = func.unoptimized_code();
     } else {
@@ skipping 60 matching lines @@
   Function& func = Function::Handle(zone());
   for (int i = 0; i < closures.Length(); i++) {
     func ^= closures.At(i);
     VisitFunction(jsarr, func);
   }
 }
 
 
 void SourceReport::PrintJSON(JSONStream* js,
                              const Script& script,
-                             intptr_t start_pos, intptr_t end_pos) {
+                             TokenPosition start_pos,
+                             TokenPosition end_pos) {
   Init(Thread::Current(), &script, start_pos, end_pos);
 
   JSONObject report(js);
   report.AddProperty("type", "SourceReport");
   {
     JSONArray ranges(&report, "ranges");
 
     const GrowableObjectArray& libs = GrowableObjectArray::Handle(
         zone(), thread()->isolate()->object_store()->libraries());
 
@@ skipping 10 matching lines @@
     VisitClosures(&ranges);
   }
 
   // Print the script table.
   JSONArray scripts(&report, "scripts");
   PrintScriptTable(&scripts);
 }
 
 
 }  // namespace dart