[kernel] Stream kernel_reader

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 221 matching lines @@
                    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(ActiveClass* active_class,
-                   Class* kernel_class,
-                   const dart::Class* klass)
-      : active_class_(active_class), saved_(*active_class) {
-    active_class_->kernel_class = kernel_class;
-    active_class_->klass = klass;
-    active_class_->member = NULL;
-
-    if (kernel_class != NULL) {
-      List<TypeParameter>& type_parameters = kernel_class->type_parameters();
-      active_class_->class_type_parameters = type_parameters.length();
-      active_class_->class_type_parameters_offset_start =
-          active_class_->class_type_parameters > 0
-              ? type_parameters[0]->kernel_offset()
-              : -1;
-    }
-  }
-
   ~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(ActiveClass* active_class, Member* member)
-      : active_class_(active_class), saved_(*active_class) {
-    // The class and kernel_class is inherited.
-    active_class_->member = member;
-
-    active_class_->member_is_procedure = false;
-    active_class_->member_is_factory_procedure = false;
-    active_class_->member_type_parameters = 0;
-    active_class_->member_type_parameters_offset_start = -1;
-
-    if (member == NULL || !member->IsProcedure()) {
-      return;
-    }
-
-    Procedure* procedure = Procedure::Cast(member);
-    active_class_->member_is_procedure = true;
-    active_class->member_is_factory_procedure =
-        procedure->kind() == Procedure::kFactory;
-    if (procedure->function() != NULL) {
-      TypeParameterList& type_parameters =
-          procedure->function()->type_parameters();
-      if (type_parameters.length() > 0) {
-        active_class_->member_type_parameters = type_parameters.length();
-        active_class_->member_type_parameters_offset_start =
-            type_parameters.first_offset;
-      }
-    }
-  }
-
   ~ActiveMemberScope() { *active_class_ = saved_; }
 
  private:
   ActiveClass* active_class_;
   ActiveClass saved_;
 };
 
 
 class TranslationHelper {
  public:
@@ skipping 75 matching lines @@
 
   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);
@@ skipping 29 matching lines @@
   Thread* thread_;
   Zone* zone_;
   Isolate* isolate_;
   Heap::Space allocation_space_;
 
   TypedData& string_offsets_;
   TypedData& string_data_;
   TypedData& canonical_names_;
 };
 
-// Regarding malformed types:
-// The spec says in section "19.1 Static Types" roughly:
-//
-//   A type T is malformed iff:
-//     * T does not denote a type in scope
-//     * T refers to a type parameter in a static member
-//     * T is a parametrized Type G<T1, ...> and G is malformed
-//     * T denotes declarations from multiple imports
-//
-// Any use of a malformed type gives rise to a static warning.  A malformed
-// type is then interpreted as dynamic by the static type checker and the
-// runtime unless explicitly specified otherwise.
-class DartTypeTranslator : public DartTypeVisitor {
- public:
-  DartTypeTranslator(TranslationHelper* helper,
-                     ActiveClass* active_class,
-                     bool finalize = false)
-      : translation_helper_(*helper),
-        active_class_(active_class),
-        type_parameter_scope_(NULL),
-        zone_(helper->zone()),
-        result_(AbstractType::Handle(helper->zone())),
-        finalize_(finalize) {}
-
-  // Can return a malformed type.
-  AbstractType& TranslateType(DartType* node);
-
-  // Can return a malformed type.
-  AbstractType& TranslateTypeWithoutFinalization(DartType* node);
-
-  // Is guaranteed to be not malformed.
-  const AbstractType& TranslateVariableType(VariableDeclaration* variable);
-
-
-  virtual void VisitDefaultDartType(DartType* node) { UNREACHABLE(); }
-
-  virtual void VisitInvalidType(InvalidType* node);
-
-  virtual void VisitFunctionType(FunctionType* node);
-
-  virtual void VisitTypeParameterType(TypeParameterType* node);
-
-  virtual void VisitInterfaceType(InterfaceType* node);
-
-  virtual void VisitDynamicType(DynamicType* node);
-
-  virtual void VisitVoidType(VoidType* node);
-
-  virtual void VisitBottomType(BottomType* node);
-
-  // Will return `TypeArguments::null()` in case any of the arguments are
-  // malformed.
-  const TypeArguments& TranslateInstantiatedTypeArguments(
-      const dart::Class& receiver_class,
-      DartType** receiver_type_arguments,
-      intptr_t length);
-
-  // Will return `TypeArguments::null()` in case any of the arguments are
-  // malformed.
-  const TypeArguments& TranslateTypeArguments(DartType** dart_types,
-                                              intptr_t length);
-
-  const Type& ReceiverType(const dart::Class& klass);
-
- private:
-  class TypeParameterScope {
-   public:
-    TypeParameterScope(DartTypeTranslator* translator,
-                       List<TypeParameter>* parameters)
-        : parameters_(parameters),
-          outer_(translator->type_parameter_scope_),
-          translator_(translator) {
-      translator_->type_parameter_scope_ = this;
-    }
-    ~TypeParameterScope() { translator_->type_parameter_scope_ = outer_; }
-
-    TypeParameterScope* outer() const { return outer_; }
-    List<TypeParameter>* parameters() const { return parameters_; }
-
-   private:
-    List<TypeParameter>* parameters_;
-    TypeParameterScope* outer_;
-    DartTypeTranslator* translator_;
-  };
-
-  TranslationHelper& translation_helper_;
-  ActiveClass* active_class_;
-  TypeParameterScope* type_parameter_scope_;
-  Zone* zone_;
-  AbstractType& result_;
-  bool finalize_;
-};
-
 
 struct FunctionScope {
   intptr_t kernel_offset;
   LocalScope* scope;
 };
 
 
 class ScopeBuildingResult : public ZoneAllocated {
  public:
   ScopeBuildingResult()
@@ skipping 296 matching lines @@
   // A chained list of try-catch blocks. Chaining and lookup is done by the
   // [TryCatchBlock] class.
   TryCatchBlock* try_catch_block_;
   intptr_t next_used_try_index_;
 
   // A chained list of catch blocks. Chaining and lookup is done by the
   // [CatchBlock] class.
   CatchBlock* catch_block_;
 
   ActiveClass active_class_;
-  DartTypeTranslator type_translator_;
 
   StreamingFlowGraphBuilder* streaming_flow_graph_builder_;
 
   friend class BreakableBlock;
   friend class CatchBlock;
   friend class ConstantEvaluator;
-  friend class DartTypeTranslator;
   friend class StreamingFlowGraphBuilder;
   friend class ScopeBuilder;
   friend class SwitchBlock;
   friend class TryCatchBlock;
   friend class TryFinallyBlock;
 };
 
 
 class SwitchBlock {
  public:
@@ skipping 95 matching lines @@
  private:
   FlowGraphBuilder* builder_;
   TryCatchBlock* outer_;
   intptr_t try_index_;
 };
 
 
 class TryFinallyBlock {
  public:
   TryFinallyBlock(FlowGraphBuilder* builder,
-                  Statement* finalizer,
                   intptr_t finalizer_kernel_offset)
       : builder_(builder),
         outer_(builder->try_finally_block_),
-        finalizer_(finalizer),
         finalizer_kernel_offset_(finalizer_kernel_offset),
         context_depth_(builder->context_depth_),
         // Finalizers are executed outside of the try block hence
         // try depth of finalizers are one less than current try
         // depth.
         try_depth_(builder->try_depth_ - 1),
         try_index_(builder_->CurrentTryIndex()) {
     builder_->try_finally_block_ = this;
   }
   ~TryFinallyBlock() { builder_->try_finally_block_ = outer_; }
 
-  Statement* finalizer() const { return finalizer_; }
   intptr_t finalizer_kernel_offset() const { return finalizer_kernel_offset_; }
   intptr_t context_depth() const { return context_depth_; }
   intptr_t try_depth() const { return try_depth_; }
   intptr_t try_index() const { return try_index_; }
   TryFinallyBlock* outer() const { return outer_; }
 
  private:
   FlowGraphBuilder* const builder_;
   TryFinallyBlock* const outer_;
-  Statement* const finalizer_;
   intptr_t finalizer_kernel_offset_;
   const intptr_t context_depth_;
   const intptr_t try_depth_;
   const intptr_t try_index_;
 };
 
 
 class BreakableBlock {
  public:
   explicit BreakableBlock(FlowGraphBuilder* builder)
@@ skipping 90 matching lines @@
 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_