Compute NativeBehavior for native methods and fields.

pkg/compiler/lib/src/kernel/kernel.dart

 // 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.md file.
 
 import 'dart:async';
 import 'dart:collection' show Queue;
 
 import 'package:kernel/ast.dart' as ir;
 import 'package:kernel/checks.dart' show CheckParentPointers;
 
 import '../common.dart';
 import '../common/names.dart';
 import '../compiler.dart' show Compiler;
 import '../constants/expressions.dart' show TypeConstantExpression;
 import '../dart_types.dart'
     show DartType, FunctionType, InterfaceType, TypeKind, TypeVariableType;
 import '../diagnostics/messages.dart' show MessageKind;
 import '../diagnostics/spannable.dart' show Spannable;
 import '../elements/elements.dart'
     show
         ClassElement,
         ConstructorElement,
         Element,
         ExportElement,
         FieldElement,
         FunctionElement,
         ImportElement,
         LibraryElement,
         LocalFunctionElement,
+        MetadataAnnotation,
         MixinApplicationElement,
         TypeVariableElement;
 import '../elements/modelx.dart' show ErroneousFieldElementX;
 import '../tree/tree.dart' show FunctionExpression, Node;
+import 'constant_visitor.dart';
 import 'kernel_visitor.dart' show IrFunction, KernelVisitor;
 
 typedef void WorkAction();
 
 class WorkItem {
   final Element element;
   final WorkAction action;
 
   WorkItem(this.element, this.action);
 }
@@ skipping 166 matching lines @@
           } else {
             internalError(member, "Unhandled class member: $member");
           }
         });
         classNode.typeParameters.addAll(typeVariablesToIr(cls.typeVariables));
         for (ir.InterfaceType interface
             in typesToIr(cls.interfaces.reverse().toList())) {
           classNode.implementedTypes.add(interface);
         }
       });
+      addWork(cls.declaration, () {
+        for (MetadataAnnotation metadata in cls.declaration.metadata) {
+          classNode.addAnnotation(
+              const ConstantVisitor().visit(metadata.constant, this));
+        }
+      });
       return classNode;
     });
   }
 
   bool hasHierarchyProblem(ClassElement cls) => cls.hasIncompleteHierarchy;
 
   ir.InterfaceType interfaceTypeToIr(InterfaceType type) {
     ir.Class cls = classToIr(type.element);
     if (type.typeArguments.isEmpty) {
       return cls.rawType;
@@ skipping 154 matching lines @@
           procedure.function = irFunction.node;
           procedure.kind = irFunction.kind;
         }
         endFactoryScope(function);
         member.transformerFlags = visitor.transformerFlags;
         assert(() {
           visitor.locals.forEach(checkMember);
           return true;
         });
       });
+      addWork(function.declaration, () {
+        for (MetadataAnnotation metadata in function.declaration.metadata) {
+          member.addAnnotation(
+              const ConstantVisitor().visit(metadata.constant, this));
+        }
+      });
       return member;
     });
   }
 
   /// Adds the type parameters of the enclosing class of [function] to
   /// [factoryTypeParameters]. This serves as a local scope for type variables
   /// resolved inside the factory.
   ///
   /// This method solves the problem that a factory method really is a generic
   /// method that has its own type parameters, one for each type parameter in
@@ skipping 41 matching lines @@
           isConst: field.isConst);
       addWork(field, () {
         setParent(fieldNode, field);
         if (!field.isMalformed && field.initializer != null) {
           KernelVisitor visitor =
               new KernelVisitor(field, field.treeElements, this);
           fieldNode.initializer = visitor.buildInitializer()
             ..parent = fieldNode;
         }
       });
+      addWork(field.declaration, () {
+        for (MetadataAnnotation metadata in field.declaration.metadata) {
+          fieldNode.addAnnotation(
+              const ConstantVisitor().visit(metadata.constant, this));
+        }
+      });
       return fieldNode;
     });
   }
 
   ir.TypeParameter typeVariableToIr(TypeVariableElement variable) {
     variable = variable.declaration;
     ir.TypeParameter parameter = factoryTypeParameters[variable];
     if (parameter != null) return parameter;
     return typeParameters.putIfAbsent(variable, () {
       ir.TypeParameter parameter = new ir.TypeParameter(variable.name, null);
@@ skipping 205 matching lines @@
 }
 
 class ConstructorTarget {
   final ConstructorElement element;
   final DartType type;
 
   ConstructorTarget(this.element, this.type);
 
   String toString() => "ConstructorTarget($element, $type)";
 }