Annotate native methods.

pkg/front_end/lib/src/fasta/kernel/kernel_procedure_builder.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 file.
 
 library fasta.kernel_procedure_builder;
 
 import 'package:kernel/ast.dart' show
     Arguments,
     AsyncMarker,
     Constructor,
+    ConstructorInvocation,
     DartType,
     DynamicType,
     EmptyStatement,
     Expression,
     FunctionNode,
     Initializer,
     Library,
     LocalInitializer,
     Member,
     Name,
     NamedExpression,
     Procedure,
     ProcedureKind,
     RedirectingInitializer,
     Statement,
+    StaticInvocation,
+    StringLiteral,
     SuperInitializer,
     TypeParameter,
     VariableDeclaration,
     VariableGet,
     VoidType,
     setParents;
 
 import 'package:kernel/type_algebra.dart' show
     containsTypeVariable,
     substitute;
 
 import '../errors.dart' show
     internalError;
 
+import '../loader.dart' show
+    Loader;
 
 import '../util/relativize.dart' show
     relativizeUri;
 
 import 'kernel_builder.dart' show
+    Builder,
     ClassBuilder,
     ConstructorReferenceBuilder,
     FormalParameterBuilder,
     KernelFormalParameterBuilder,
     KernelLibraryBuilder,
     KernelTypeBuilder,
     KernelTypeVariableBuilder,
     MetadataBuilder,
     ProcedureBuilder,
     TypeVariableBuilder,
     memberError;
 
 abstract class KernelFunctionBuilder
     extends ProcedureBuilder<KernelTypeBuilder> {
+  final String nativeMethodName;
+
   FunctionNode function;
 
   Statement actualBody;
 
-  KernelFunctionBuilder(
-      List<MetadataBuilder> metadata,
-      int modifiers, KernelTypeBuilder returnType, String name,
+  KernelFunctionBuilder(List<MetadataBuilder> metadata, int modifiers,
+      KernelTypeBuilder returnType, String name,
       List<TypeVariableBuilder> typeVariables,
       List<FormalParameterBuilder> formals,
-      KernelLibraryBuilder compilationUnit, int charOffset)
+      KernelLibraryBuilder compilationUnit, int charOffset,
+      this.nativeMethodName)
       : super(metadata, modifiers, returnType, name, typeVariables, formals,
           compilationUnit, charOffset);
 
   void set body(Statement newBody) {
     if (isAbstract && newBody != null) {
       return internalError("Attempting to set body on abstract method.");
     }
     actualBody = newBody;
     if (function != null) {
       function.body = newBody;
       newBody?.parent = function;
     }
   }
 
   Statement get body => actualBody ??= new EmptyStatement();
 
+  bool get isNative => nativeMethodName != null;
+
   FunctionNode buildFunction() {
     assert(function == null);
     FunctionNode result = new FunctionNode(body, asyncMarker: asyncModifier);
     if (typeVariables != null) {
       for (KernelTypeVariableBuilder t in typeVariables) {
         result.typeParameters.add(t.parameter);
       }
       setParents(result.typeParameters, result);
     }
     if (formals != null) {
@@ skipping 40 matching lines @@
         }
         if (containsTypeVariable(result.returnType, set)) {
           result.returnType = removeTypeVariables(result.returnType);
         }
       }
     }
     return function = result;
   }
 
   Member build(Library library);
+
+  void becomeNative(Loader loader) {
+    target.isExternal = true;
+    Builder constructor = loader.getNativeAnnotation();
+    Arguments arguments =
+        new Arguments(<Expression>[new StringLiteral(nativeMethodName)]);
+    Expression annotation;
+    if (constructor.isConstructor) {
+      annotation = new ConstructorInvocation(constructor.target, arguments)
+          ..isConst = true;
+    } else {
+      annotation = new StaticInvocation(constructor.target, arguments)
+          ..isConst = true;
+    }
+    target.addAnnotation(annotation);
+  }
 }
 
 class KernelProcedureBuilder extends KernelFunctionBuilder {
   final Procedure procedure;
 
   AsyncMarker actualAsyncModifier;
 
   final ConstructorReferenceBuilder redirectionTarget;
 
   KernelProcedureBuilder(
       List<MetadataBuilder> metadata,
       int modifiers, KernelTypeBuilder returnType, String name,
       List<TypeVariableBuilder> typeVariables,
       List<FormalParameterBuilder> formals, this.actualAsyncModifier,
       ProcedureKind kind, KernelLibraryBuilder compilationUnit, int charOffset,
-      [this.redirectionTarget])
+      [String nativeMethodName, this.redirectionTarget])
       : procedure = new Procedure(null, kind, null,
             fileUri: relativizeUri(compilationUnit?.fileUri)),
         super(metadata, modifiers, returnType, name, typeVariables, formals,
-            compilationUnit, charOffset);
+            compilationUnit, charOffset, nativeMethodName);
 
   ProcedureKind get kind => procedure.kind;
 
   AsyncMarker get asyncModifier => actualAsyncModifier;
 
   Statement get body {
     if (actualBody == null && redirectionTarget == null && !isAbstract &&
         !isExternal) {
       actualBody = new EmptyStatement();
     }
@@ skipping 33 matching lines @@
 
   SuperInitializer superInitializer;
 
   RedirectingInitializer redirectingInitializer;
 
   KernelConstructorBuilder(
       List<MetadataBuilder> metadata,
       int modifiers, KernelTypeBuilder returnType, String name,
       List<TypeVariableBuilder> typeVariables,
       List<FormalParameterBuilder> formals,
-      KernelLibraryBuilder compilationUnit, int charOffset)
+      KernelLibraryBuilder compilationUnit, int charOffset,
+      [String nativeMethodName])
       : super(metadata, modifiers, returnType, name, typeVariables, formals,
-          compilationUnit, charOffset);
+          compilationUnit, charOffset, nativeMethodName);
 
   bool get isInstanceMember => false;
 
   bool get isConstructor => true;
 
   AsyncMarker get asyncModifier => AsyncMarker.Sync;
 
   ProcedureKind get kind => null;
 
   Constructor build(Library library) {
@@ skipping 69 matching lines @@
         }
       }
       initializers.add(initializer..parent = constructor);
       initializers.add(superInitializer);
       return;
     }
     initializers.add(initializer);
     initializer.parent = constructor;
   }
 }