[kernel] Delete most of the AST

runtime/vm/kernel_to_il.h

 // 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.
 
 #ifndef RUNTIME_VM_KERNEL_TO_IL_H_
 #define RUNTIME_VM_KERNEL_TO_IL_H_
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
 #include "vm/growable_array.h"
@@ skipping 181 matching lines @@
 typedef ZoneGrowableArray<PushArgumentInstr*>* ArgumentArray;
 
 
 class ActiveClass {
  public:
   ActiveClass()
       : kernel_class(NULL),
         class_type_parameters(0),
         class_type_parameters_offset_start(-1),
         klass(NULL),
-        member(NULL),
         member_is_procedure(false),
         member_is_factory_procedure(false),
         member_type_parameters(0),
         member_type_parameters_offset_start(-1) {}
 
   // The current enclosing kernel class (if available, otherwise NULL).
   Class* kernel_class;
   intptr_t class_type_parameters;
   intptr_t class_type_parameters_offset_start;
 
   // The current enclosing class (or the library top-level class).  When this is
   // a library's top-level class, the kernel_class will be NULL.
   const dart::Class* klass;
 
-  // The enclosing member (e.g., Constructor, Procedure, or Field) if there
-  // is one.
-  Member* member;
   bool member_is_procedure;
   bool member_is_factory_procedure;
   intptr_t member_type_parameters;
   intptr_t member_type_parameters_offset_start;
 };
 
 
 class ActiveClassScope {
  public:
   ActiveClassScope(ActiveClass* active_class,
                    intptr_t class_type_parameters,
                    intptr_t class_type_parameters_offset_start,
                    const dart::Class* klass)
       : active_class_(active_class), saved_(*active_class) {
     active_class_->kernel_class = NULL;
     active_class_->class_type_parameters = class_type_parameters;
     active_class_->class_type_parameters_offset_start =
         class_type_parameters_offset_start;
     active_class_->klass = klass;
-    active_class_->member = NULL;
   }
 
   ~ActiveClassScope() { *active_class_ = saved_; }
 
  private:
   ActiveClass* active_class_;
   ActiveClass saved_;
 };
 
 
 class ActiveMemberScope {
  public:
   ActiveMemberScope(ActiveClass* active_class,
                     bool member_is_procedure,
                     bool member_is_factory_procedure,
                     intptr_t member_type_parameters,
                     intptr_t member_type_parameters_offset_start)
       : active_class_(active_class), saved_(*active_class) {
     // The class and kernel_class is inherited.
-    active_class_->member = NULL;
     active_class_->member_is_procedure = member_is_procedure;
     active_class_->member_is_factory_procedure = member_is_factory_procedure;
     active_class_->member_type_parameters = member_type_parameters;
     active_class_->member_type_parameters_offset_start =
         member_type_parameters_offset_start;
   }
 
   ~ActiveMemberScope() { *active_class_ = saved_; }
 
  private:
@@ skipping 74 matching lines @@
   dart::String& DartSymbol(StringIndex string_index) const;
   dart::String& DartSymbol(const uint8_t* utf8_array, intptr_t len) const;
 
   const dart::String& DartClassName(NameIndex kernel_class);
 
   const dart::String& DartConstructorName(NameIndex constructor);
 
   const dart::String& DartProcedureName(NameIndex procedure);
 
   const dart::String& DartSetterName(NameIndex setter);
-  const dart::String& DartSetterName(Name* setter_name);
   const dart::String& DartSetterName(NameIndex parent, StringIndex setter);
 
   const dart::String& DartGetterName(NameIndex getter);
-  const dart::String& DartGetterName(Name* getter_name);
   const dart::String& DartGetterName(NameIndex parent, StringIndex getter);
 
-  const dart::String& DartFieldName(Name* kernel_name);
   const dart::String& DartFieldName(NameIndex parent, StringIndex field);
 
-  const dart::String& DartInitializerName(Name* kernel_name);
-
   const dart::String& DartMethodName(NameIndex method);
-  const dart::String& DartMethodName(Name* method_name);
   const dart::String& DartMethodName(NameIndex parent, StringIndex method);
 
   const dart::String& DartFactoryName(NameIndex factory);
 
-  const Array& ArgumentNames(List<NamedExpression>* named);
-
   // A subclass overrides these when reading in the Kernel program in order to
   // support recursive type expressions (e.g. for "implements X" ...
   // annotations).
   virtual RawLibrary* LookupLibraryByKernelLibrary(NameIndex library);
   virtual RawClass* LookupClassByKernelClass(NameIndex klass);
 
   RawField* LookupFieldByKernelField(NameIndex field);
   RawFunction* LookupStaticMethodByKernelProcedure(NameIndex procedure);
   RawFunction* LookupConstructorByKernelConstructor(NameIndex constructor);
   dart::RawFunction* LookupConstructorByKernelConstructor(
@@ skipping 167 matching lines @@
   Fragment CheckStackOverflow();
   Fragment CloneContext();
   Fragment Constant(const Object& value);
   Fragment CreateArray();
   Fragment Goto(JoinEntryInstr* destination);
   Fragment IntConstant(int64_t value);
   Fragment InstanceCall(TokenPosition position,
                         const dart::String& name,
                         Token::Kind kind,
                         intptr_t argument_count,
-                        intptr_t num_args_checked = 1);
+                        intptr_t checked_argument_count = 1);
   Fragment InstanceCall(TokenPosition position,
                         const dart::String& name,
                         Token::Kind kind,
                         intptr_t argument_count,
                         const Array& argument_names,
-                        intptr_t num_args_checked = 1);
+                        intptr_t checked_argument_count = 1);
   Fragment ClosureCall(intptr_t type_args_len,
                        intptr_t argument_count,
                        const Array& argument_names);
   Fragment ThrowException(TokenPosition position);
   Fragment RethrowException(TokenPosition position, int catch_try_index);
   Fragment LoadClassId();
   Fragment LoadField(const dart::Field& field);
   Fragment LoadField(intptr_t offset, intptr_t class_id = kDynamicCid);
   Fragment LoadNativeField(MethodRecognizer::Kind kind,
                            intptr_t offset,
@@ skipping 160 matching lines @@
   friend class StreamingFlowGraphBuilder;
   friend class ScopeBuilder;
   friend class SwitchBlock;
   friend class TryCatchBlock;
   friend class TryFinallyBlock;
 };
 
 
 class SwitchBlock {
  public:
-  SwitchBlock(FlowGraphBuilder* builder, intptr_t num_cases)
+  SwitchBlock(FlowGraphBuilder* builder, intptr_t case_count)
       : builder_(builder),
         outer_(builder->switch_block_),
         outer_finally_(builder->try_finally_block_),
-        num_cases_(num_cases),
+        case_count_(case_count),
         context_depth_(builder->context_depth_),
         try_index_(builder->CurrentTryIndex()) {
     builder_->switch_block_ = this;
     if (outer_ != NULL) {
-      depth_ = outer_->depth_ + outer_->num_cases_;
+      depth_ = outer_->depth_ + outer_->case_count_;
     } else {
       depth_ = 0;
     }
   }
   ~SwitchBlock() { builder_->switch_block_ = outer_; }
 
   bool HadJumper(intptr_t case_num) {
     return destinations_.Lookup(case_num) != NULL;
   }
 
@@ skipping 43 matching lines @@
     }
     return cached_inst;
   }
 
   FlowGraphBuilder* builder_;
   SwitchBlock* outer_;
 
   IntMap<JoinEntryInstr*> destinations_;
 
   TryFinallyBlock* outer_finally_;
-  intptr_t num_cases_;
+  intptr_t case_count_;
   intptr_t depth_;
   intptr_t context_depth_;
   intptr_t try_index_;
 };
 
 
 class TryCatchBlock {
  public:
   explicit TryCatchBlock(FlowGraphBuilder* builder,
                          intptr_t try_handler_index = -1)
@@ skipping 123 matching lines @@
   FlowGraphBuilder* builder_;
   CatchBlock* outer_;
   LocalVariable* exception_var_;
   LocalVariable* stack_trace_var_;
   intptr_t catch_try_index_;
 };
 
 
 RawObject* EvaluateMetadata(const dart::Field& metadata_field);
 RawObject* BuildParameterDescriptor(const Function& function);
+void CollectTokenPositionsFor(const Script& script);
+String& GetSourceFor(const Script& script);
+Array& GetLineStartsFor(const Script& script);
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #else  // !defined(DART_PRECOMPILED_RUNTIME)
 
 #include "vm/object.h"
 #include "vm/kernel.h"
 
 namespace dart {
 namespace kernel {
 
 RawObject* EvaluateMetadata(const dart::Field& metadata_field);
 RawObject* BuildParameterDescriptor(const Function& function);
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 #endif  // RUNTIME_VM_KERNEL_TO_IL_H_