VM: [Kernel] Partial support for metadata annotations

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 <map>
 #include <set>
 #include <string>
 
 #include "vm/kernel_to_il.h"
 
@@ skipping 1301 matching lines @@
 
 ConstantEvaluator::ConstantEvaluator(FlowGraphBuilder* builder,
                                      Zone* zone,
                                      TranslationHelper* h,
                                      DartTypeTranslator* type_translator)
     : builder_(builder),
       isolate_(Isolate::Current()),
       zone_(zone),
       translation_helper_(*h),
       type_translator_(*type_translator),
-      script_(dart::Script::Handle(
+      script_(Script::Handle(
           zone,
-          builder_->parsed_function_->function().script())),
-      result_(dart::Instance::Handle(zone)) {}
+          builder == NULL ? Script::null()
+                          : builder_->parsed_function_->function().script())),
+      result_(Instance::Handle(zone)) {}
 
 
 Instance& ConstantEvaluator::EvaluateExpression(Expression* expression) {
   if (!GetCachedConstant(expression, &result_)) {
     expression->AcceptExpressionVisitor(this);
     CacheConstantValue(expression, result_);
   }
   // We return a new `ZoneHandle` here on purpose: The intermediate language
   // instructions do not make a copy of the handle, so we do it.
   return dart::Instance::ZoneHandle(Z, result_.raw());
@@ skipping 125 matching lines @@
   ASSERT(!result.IsError());
   if (constructor.IsFactory()) {
     // The factory method returns the allocated object.
     instance ^= result.raw();
   }
   return H.Canonicalize(instance);
 }
 
 
 bool ConstantEvaluator::GetCachedConstant(TreeNode* node, Instance* value) {
+  if (builder_ == NULL) return false;
+
   const Function& function = builder_->parsed_function_->function();
   if (function.kind() == RawFunction::kImplicitStaticFinalGetter) {
     // Don't cache constants in initializer expressions. They get
     // evaluated only once.
     return false;
   }
 
   bool is_present = false;
   ASSERT(!script_.InVMHeap());
   if (script_.compile_time_constants() == Array::null()) {
     return false;
   }
   KernelConstantsMap constants(script_.compile_time_constants());
   *value ^= constants.GetOrNull(node, &is_present);
   // Mutator compiler thread may add constants while background compiler
   // is running, and thus change the value of 'compile_time_constants';
   // do not assert that 'compile_time_constants' has not changed.
   constants.Release();
   if (FLAG_compiler_stats && is_present) {
     H.thread()->compiler_stats()->num_const_cache_hits++;
   }
   return is_present;
 }
 
 
 void ConstantEvaluator::CacheConstantValue(TreeNode* node,
                                            const Instance& value) {
   ASSERT(Thread::Current()->IsMutatorThread());
 
+  if (builder_ == NULL) return;
+
   const Function& function = builder_->parsed_function_->function();
   if (function.kind() == RawFunction::kImplicitStaticFinalGetter) {
     // Don't cache constants in initializer expressions. They get
     // evaluated only once.
     return;
   }
   const intptr_t kInitialConstMapSize = 16;
   ASSERT(!script_.InVMHeap());
   if (script_.compile_time_constants() == Array::null()) {
     const Array& array = Array::Handle(
@@ skipping 4404 matching lines @@
   instructions += StoreInstanceField(Closure::function_offset());
 
   instructions += LoadLocal(closure);
   instructions += LoadLocal(parsed_function_->current_context_var());
   instructions += StoreInstanceField(Closure::context_offset());
 
   return instructions;
 }
 
 
+RawObject* EvaluateMetadata(TreeNode* kernel_node) {
+  LongJumpScope jump;
+  if (setjmp(*jump.Set()) == 0) {
+    Thread* thread = Thread::Current();
+    Zone* zone_ = thread->zone();
+
+    List<Expression>* metadata_expressions = NULL;
+    if (kernel_node->IsClass()) {
+      metadata_expressions = &Class::Cast(kernel_node)->annotations();
+    } else if (kernel_node->IsProcedure()) {
+      metadata_expressions = &Procedure::Cast(kernel_node)->annotations();
+    } else if (kernel_node->IsField()) {
+      metadata_expressions = &Field::Cast(kernel_node)->annotations();
+    } else if (kernel_node->IsConstructor()) {
+      metadata_expressions = &Constructor::Cast(kernel_node)->annotations();
+    } else {
+      FATAL1("No support for metadata on this type of kernel node %p\n",
+             kernel_node);
+    }
+
+    TranslationHelper translation_helper(thread);
+    DartTypeTranslator type_translator(&translation_helper, NULL, true);
+    ConstantEvaluator constant_evaluator(/* flow_graph_builder = */ NULL, Z,
+                                         &translation_helper, &type_translator);
+
+    const Array& metadata_values =
+        Array::Handle(Z, Array::New(metadata_expressions->length()));
+
+    for (intptr_t i = 0; i < metadata_expressions->length(); i++) {
+      const Instance& value =
+          constant_evaluator.EvaluateExpression((*metadata_expressions)[i]);
+      metadata_values.SetAt(i, value);
+    }
+
+    return metadata_values.raw();
+  } else {
+    Thread* thread = Thread::Current();
+    Error& error = Error::Handle();
+    error = thread->sticky_error();
+    thread->clear_sticky_error();
+    return error.raw();
+  }
+}
+
+
+RawObject* BuildParameterDescriptor(TreeNode* kernel_node) {
+  LongJumpScope jump;
+  if (setjmp(*jump.Set()) == 0) {
+    FunctionNode* function_node = NULL;
+
+    if (kernel_node->IsProcedure()) {
+      function_node = Procedure::Cast(kernel_node)->function();
+    } else if (kernel_node->IsConstructor()) {
+      function_node = Constructor::Cast(kernel_node)->function();
+    } else if (kernel_node->IsFunctionNode()) {
+      function_node = FunctionNode::Cast(kernel_node);
+    } else {
+      UNIMPLEMENTED();
+      return NULL;
+    }
+
+    Thread* thread = Thread::Current();
+    Zone* zone_ = thread->zone();
+    TranslationHelper translation_helper(thread);
+    DartTypeTranslator type_translator(&translation_helper, NULL, true);
+    ConstantEvaluator constant_evaluator(/* flow_graph_builder = */ NULL, Z,
+                                         &translation_helper, &type_translator);
+
+
+    intptr_t param_count = function_node->positional_parameters().length() +
+                           function_node->named_parameters().length();
+    const Array& param_descriptor = Array::Handle(
+        Array::New(param_count * Parser::kParameterEntrySize, Heap::kOld));
+    for (intptr_t i = 0; i < param_count; ++i) {
+      VariableDeclaration* variable;
+      if (i < function_node->positional_parameters().length()) {
+        variable = function_node->positional_parameters()[i];
+      } else {
+        variable = function_node->named_parameters()[i];
+      }
+
+      param_descriptor.SetAt(
+          i + Parser::kParameterIsFinalOffset,
+          variable->IsFinal() ? Bool::True() : Bool::False());
+
+      if (variable->initializer() != NULL) {
+        param_descriptor.SetAt(
+            i + Parser::kParameterDefaultValueOffset,
+            constant_evaluator.EvaluateExpression(variable->initializer()));
+      } else {
+        param_descriptor.SetAt(i + Parser::kParameterDefaultValueOffset,
+                               Object::null_instance());
+      }
+
+      param_descriptor.SetAt(i + Parser::kParameterMetadataOffset,
+                             /* Issue(28434): Missing parameter metadata. */
+                             Object::null_instance());
+    }
+    return param_descriptor.raw();
+  } else {
+    Thread* thread = Thread::Current();
+    Error& error = Error::Handle();
+    error = thread->sticky_error();
+    thread->clear_sticky_error();
+    return error.raw();
+  }
+}
+
+
 }  // namespace kernel
 }  // namespace dart
+
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)