[kernel] Delete most of the AST

runtime/vm/kernel_to_il.cc

 // Copyright (c) 2016, 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 <set>
 
 #include "vm/kernel_to_il.h"
 
 #include "vm/compiler.h"
 #include "vm/intermediate_language.h"
@@ skipping 365 matching lines @@
   }
 }
 
 
 const dart::String& TranslationHelper::DartSetterName(NameIndex setter) {
   return DartSetterName(CanonicalNameParent(setter),
                         CanonicalNameString(setter));
 }
 
 
-const dart::String& TranslationHelper::DartSetterName(Name* setter_name) {
-  return DartSetterName(setter_name->library(), setter_name->string_index());
-}
-
-
 const dart::String& TranslationHelper::DartSetterName(NameIndex parent,
                                                       StringIndex setter) {
   // The names flowing into [setter] are coming from the Kernel file:
   //   * user-defined setters: `fieldname=`
   //   * property-set expressions:  `fieldname`
   //
   // The VM uses `get:fieldname` and `set:fieldname`.
   //
   // => In order to be consistent, we remove the `=` always and adopt the VM
   //    conventions.
@@ skipping 14 matching lines @@
   return name;
 }
 
 
 const dart::String& TranslationHelper::DartGetterName(NameIndex getter) {
   return DartGetterName(CanonicalNameParent(getter),
                         CanonicalNameString(getter));
 }
 
 
-const dart::String& TranslationHelper::DartGetterName(Name* getter_name) {
-  return DartGetterName(getter_name->library(), getter_name->string_index());
-}
-
-
 const dart::String& TranslationHelper::DartGetterName(NameIndex parent,
                                                       StringIndex getter) {
   dart::String& name = DartString(getter);
   ManglePrivateName(parent, &name, false);
   name = dart::Field::GetterSymbol(name);
   return name;
 }
 
 
-const dart::String& TranslationHelper::DartFieldName(Name* kernel_name) {
-  dart::String& name = DartString(kernel_name->string_index());
-  return ManglePrivateName(kernel_name->library(), &name);
-}
-
-
 const dart::String& TranslationHelper::DartFieldName(NameIndex parent,
                                                      StringIndex field) {
   dart::String& name = DartString(field);
   return ManglePrivateName(parent, &name);
 }
 
 
-const dart::String& TranslationHelper::DartInitializerName(Name* kernel_name) {
-  // The [DartFieldName] will take care of mangling the name.
-  dart::String& name =
-      dart::String::Handle(Z, DartFieldName(kernel_name).raw());
-  name = Symbols::FromConcat(thread_, Symbols::InitPrefix(), name);
-  return name;
-}
-
-
 const dart::String& TranslationHelper::DartMethodName(NameIndex method) {
   return DartMethodName(CanonicalNameParent(method),
                         CanonicalNameString(method));
 }
 
 
-const dart::String& TranslationHelper::DartMethodName(Name* method_name) {
-  return DartMethodName(method_name->library(), method_name->string_index());
-}
-
-
 const dart::String& TranslationHelper::DartMethodName(NameIndex parent,
                                                       StringIndex method) {
   dart::String& name = DartString(method);
   return ManglePrivateName(parent, &name);
 }
 
 
 const dart::String& TranslationHelper::DartFactoryName(NameIndex factory) {
   ASSERT(IsConstructor(factory) || IsFactory(factory));
   GrowableHandlePtrArray<const dart::String> pieces(Z, 3);
@@ skipping 157 matching lines @@
     const dart::Library& library =
         dart::Library::Handle(Z, LookupLibraryByKernelLibrary(parent));
     *name_to_modify = library.PrivateName(*name_to_modify);
   } else if (symbolize) {
     *name_to_modify = Symbols::New(thread_, *name_to_modify);
   }
   return *name_to_modify;
 }
 
 
-const Array& TranslationHelper::ArgumentNames(List<NamedExpression>* named) {
-  if (named->length() == 0) return Array::ZoneHandle(Z);
-
-  const Array& names =
-      Array::ZoneHandle(Z, Array::New(named->length(), Heap::kOld));
-  for (intptr_t i = 0; i < named->length(); ++i) {
-    names.SetAt(i, DartSymbol((*named)[i]->name()));
-  }
-  return names;
-}
-
-
 FlowGraphBuilder::FlowGraphBuilder(
     intptr_t kernel_offset,
     ParsedFunction* parsed_function,
     const ZoneGrowableArray<const ICData*>& ic_data_array,
     ZoneGrowableArray<intptr_t>* context_level_array,
     InlineExitCollector* exit_collector,
     intptr_t osr_id,
     intptr_t first_block_id)
     : translation_helper_(Thread::Current()),
       thread_(translation_helper_.thread()),
@@ skipping 477 matching lines @@
 Fragment FlowGraphBuilder::IntConstant(int64_t value) {
   return Fragment(
       Constant(Integer::ZoneHandle(Z, Integer::New(value, Heap::kOld))));
 }
 
 
 Fragment FlowGraphBuilder::InstanceCall(TokenPosition position,
                                         const dart::String& name,
                                         Token::Kind kind,
                                         intptr_t argument_count,
-                                        intptr_t num_args_checked) {
+                                        intptr_t checked_argument_count) {
   return InstanceCall(position, name, kind, argument_count, Array::null_array(),
-                      num_args_checked);
+                      checked_argument_count);
 }
 
 
 Fragment FlowGraphBuilder::InstanceCall(TokenPosition position,
                                         const dart::String& name,
                                         Token::Kind kind,
                                         intptr_t argument_count,
                                         const Array& argument_names,
-                                        intptr_t num_args_checked) {
+                                        intptr_t checked_argument_count) {
   ArgumentArray arguments = GetArguments(argument_count);
   const intptr_t kTypeArgsLen = 0;  // Generic instance calls not yet supported.
   InstanceCallInstr* call = new (Z) InstanceCallInstr(
       position, name, kind, arguments, kTypeArgsLen, argument_names,
-      num_args_checked, ic_data_array_, GetNextDeoptId());
+      checked_argument_count, ic_data_array_, GetNextDeoptId());
   Push(call);
   return Fragment(call);
 }
 
 
 Fragment FlowGraphBuilder::ClosureCall(intptr_t type_args_len,
                                        intptr_t argument_count,
                                        const Array& argument_names) {
   Value* function = Pop();
   const intptr_t total_count = argument_count + (type_args_len > 0 ? 1 : 0);
@@ skipping 478 matching lines @@
 
 intptr_t FlowGraphBuilder::CurrentTryIndex() {
   if (try_catch_block_ == NULL) {
     return CatchClauseNode::kInvalidTryIndex;
   } else {
     return try_catch_block_->try_index();
   }
 }
 
 
-LocalVariable* FlowGraphBuilder::LookupVariable(VariableDeclaration* var) {
-  LocalVariable* local = scopes_->locals.Lookup(var->kernel_offset_no_tag());
-  ASSERT(local != NULL);
-  return local;
-}
-
-
 dart::LocalVariable* FlowGraphBuilder::LookupVariable(intptr_t kernel_offset) {
   LocalVariable* local = scopes_->locals.Lookup(kernel_offset);
   ASSERT(local != NULL);
   return local;
 }
 
 
 void FlowGraphBuilder::SetTempIndex(Definition* definition) {
   definition->set_temp_index(
       stack_ == NULL ? 0 : stack_->definition()->temp_index() + 1);
@@ skipping 749 matching lines @@
         function.kernel_offset());
   } else {
     Thread* thread = Thread::Current();
     Error& error = Error::Handle();
     error = thread->sticky_error();
     thread->clear_sticky_error();
     return error.raw();
   }
 }
 
+static int LowestFirst(const intptr_t* a, const intptr_t* b) {
+  return *a - *b;
+}
+
+/**
+ * If index exists as sublist in list, sort the sublist from lowest to highest,
+ * then copy it, as Smis and without duplicates,
+ * to a new Array in Heap::kOld which is returned.
+ * Note that the source list is both sorted and de-duplicated as well, but will
+ * possibly contain duplicate and unsorted data at the end.
+ * Otherwise (when sublist doesn't exist in list) return new empty array.
+ */
+static RawArray* AsSortedDuplicateFreeArray(GrowableArray<intptr_t>* source) {
+  intptr_t size = source->length();
+  if (size == 0) {
+    return Array::New(0);
+  }
+
+  source->Sort(LowestFirst);
+
+  intptr_t last = 0;
+  for (intptr_t current = 1; current < size; ++current) {
+    if (source->At(last) != source->At(current)) {
+      (*source)[++last] = source->At(current);
+    }
+  }
+  Array& array_object = Array::Handle();
+  array_object = Array::New(last + 1, Heap::kOld);
+  Smi& smi_value = Smi::Handle();
+  for (intptr_t i = 0; i <= last; ++i) {
+    smi_value = Smi::New(source->At(i));
+    array_object.SetAt(i, smi_value);
+  }
+  return array_object.raw();
+}
+
+void CollectTokenPositionsFor(const Script& const_script) {
+  Thread* thread = Thread::Current();
+  Zone* zone_ = thread->zone();
+  Script& script = Script::Handle(Z, const_script.raw());
+  TranslationHelper helper(thread);
+  helper.SetStringOffsets(TypedData::Handle(Z, script.kernel_string_offsets()));
+  helper.SetStringData(TypedData::Handle(Z, script.kernel_string_data()));
+  helper.SetCanonicalNames(
+      TypedData::Handle(Z, script.kernel_canonical_names()));
+
+  GrowableArray<intptr_t> token_positions(10);
+  GrowableArray<intptr_t> yield_positions(1);
+  StreamingFlowGraphBuilder streaming_flow_graph_builder(
+      &helper, zone_, script.kernel_data(), script.kernel_data_size());
+  streaming_flow_graph_builder.CollectTokenPositionsFor(
+      script.kernel_script_index(), &token_positions, &yield_positions);
+  Array& array_object = Array::Handle(Z);
+  array_object = AsSortedDuplicateFreeArray(&token_positions);
+  script.set_debug_positions(array_object);
+  array_object = AsSortedDuplicateFreeArray(&yield_positions);
+  script.set_yield_positions(array_object);
+}
+
+String& GetSourceFor(const Script& const_script) {
+  Thread* thread = Thread::Current();
+  Zone* zone_ = thread->zone();
+  Script& script = Script::Handle(Z, const_script.raw());
+  TranslationHelper helper(thread);
+  helper.SetStringOffsets(TypedData::Handle(Z, script.kernel_string_offsets()));
+  helper.SetStringData(TypedData::Handle(Z, script.kernel_string_data()));
+  helper.SetCanonicalNames(
+      TypedData::Handle(Z, script.kernel_canonical_names()));
+
+  StreamingFlowGraphBuilder streaming_flow_graph_builder(
+      &helper, zone_, script.kernel_data(), script.kernel_data_size());
+  return streaming_flow_graph_builder.GetSourceFor(
+      script.kernel_script_index());
+}
+
+Array& GetLineStartsFor(const Script& const_script) {
+  Thread* thread = Thread::Current();
+  Zone* zone_ = thread->zone();
+  Script& script = Script::Handle(Z, const_script.raw());
+  TranslationHelper helper(thread);
+  helper.SetStringOffsets(TypedData::Handle(Z, script.kernel_string_offsets()));
+  helper.SetStringData(TypedData::Handle(Z, script.kernel_string_data()));
+  helper.SetCanonicalNames(
+      TypedData::Handle(Z, script.kernel_canonical_names()));
+
+  StreamingFlowGraphBuilder streaming_flow_graph_builder(
+      &helper, zone_, script.kernel_data(), script.kernel_data_size());
+  return streaming_flow_graph_builder.GetLineStartsFor(
+      script.kernel_script_index());
+}
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)