Annotate native methods.

pkg/front_end/lib/src/fasta/kernel/kernel_library_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_library_builder;
 
 import 'package:kernel/ast.dart';
 
 import 'package:kernel/clone.dart' show
     CloneVisitor;
@@ skipping 47 matching lines @@
     TypeVariableBuilder;
 
 class KernelLibraryBuilder
     extends SourceLibraryBuilder<KernelTypeBuilder, Library> {
   final Library library;
 
   final List<Class> mixinApplicationClasses = <Class>[];
 
   final List<List> argumentsWithMissingDefaultValues = <List>[];
 
+  final List<KernelProcedureBuilder> nativeMethods = <KernelProcedureBuilder>[];
+
   final List<KernelTypeVariableBuilder> boundlessTypeVariables =
       <KernelTypeVariableBuilder>[];
 
   KernelLibraryBuilder(Uri uri, Uri fileUri, Loader loader)
       : library = new Library(uri, fileUri: relativizeUri(fileUri)),
         super(loader, fileUri);
 
   Uri get uri => library.importUri;
 
   KernelTypeBuilder addNamedType(String name,
@@ skipping 56 matching lines @@
   void addField(List<MetadataBuilder> metadata,
       int modifiers, KernelTypeBuilder type, String name, int charOffset) {
     addBuilder(name, new KernelFieldBuilder(
             metadata, type, name, modifiers, this, charOffset), charOffset);
   }
 
   void addProcedure(List<MetadataBuilder> metadata,
       int modifiers, KernelTypeBuilder returnType, String name,
       List<TypeVariableBuilder> typeVariables,
       List<FormalParameterBuilder> formals, AsyncMarker asyncModifier,
-      ProcedureKind kind, int charOffset, {bool isTopLevel}) {
+      ProcedureKind kind, int charOffset, String nativeMethodName,
+      {bool isTopLevel}) {
     // Nested declaration began in `OutlineBuilder.beginMethod` or
     // `OutlineBuilder.beginTopLevelMethod`.
     endNestedDeclaration().resolveTypes(typeVariables, this);
     ProcedureBuilder procedure;
     if (!isTopLevel && isConstructorName(name, currentDeclaration.name)) {
       int index = name.indexOf(".");
       name = index == -1 ? "" : name.substring(index + 1);
       procedure = new KernelConstructorBuilder(metadata,
           modifiers & ~abstractMask, returnType, name, typeVariables, formals,
-          this, charOffset);
+          this, charOffset, nativeMethodName);
     } else {
       procedure = new KernelProcedureBuilder(metadata, modifiers, returnType,
-          name, typeVariables, formals, asyncModifier, kind, this, charOffset);
+          name, typeVariables, formals, asyncModifier, kind, this, charOffset,
+          nativeMethodName);
     }
     addBuilder(name, procedure, charOffset);
+    if (nativeMethodName != null) {
+      addNativeMethod(procedure);
+    }
   }
 
   void addFactoryMethod(List<MetadataBuilder> metadata,
       ConstructorReferenceBuilder constructorName,
       List<FormalParameterBuilder> formals, AsyncMarker asyncModifier,
-      ConstructorReferenceBuilder redirectionTarget, int charOffset) {
+      ConstructorReferenceBuilder redirectionTarget, int charOffset,
+      String nativeMethodName) {
     // Nested declaration began in `OutlineBuilder.beginFactoryMethod`.
     DeclarationBuilder<KernelTypeBuilder> factoryDeclaration =
         endNestedDeclaration();
     String name = constructorName.name;
     int index = name.indexOf(".");
     name = index == -1 ? "" : name.substring(index + 1);
     assert(constructorName.suffix == null);
     KernelProcedureBuilder procedure = new KernelProcedureBuilder(metadata,
         staticMask, null, name, <TypeVariableBuilder>[], formals, asyncModifier,
-        ProcedureKind.Factory, this, charOffset, redirectionTarget);
+        ProcedureKind.Factory, this, charOffset, nativeMethodName,
+        redirectionTarget);
     currentDeclaration.addFactoryDeclaration(procedure, factoryDeclaration);
     addBuilder(name, procedure, charOffset);
+    if (nativeMethodName != null) {
+      addNativeMethod(procedure);
+    }
   }
 
   void addEnum(List<MetadataBuilder> metadata, String name,
       List<String> constants, int charOffset) {
     addBuilder(name,
         new KernelEnumBuilder(metadata, name, constants, this, charOffset),
         charOffset);
   }
 
   void addFunctionTypeAlias(List<MetadataBuilder> metadata,
@@ skipping 114 matching lines @@
           }
           expression.value =
               defaultArgumentFrom(names[expression.name].initializer)
               ..parent = expression;
         }
       }
     }
     return argumentsWithMissingDefaultValues.length;
   }
 
+  void addNativeMethod(KernelProcedureBuilder method) {
+    nativeMethods.add(method);
+  }
+
+  int finishNativeMethods() {
+    for (KernelProcedureBuilder method in nativeMethods) {
+      method.becomeNative(loader);
+    }
+    return nativeMethods.length;
+  }
+
   List<TypeVariableBuilder> copyTypeVariables(
       List<TypeVariableBuilder> original) {
     List<TypeVariableBuilder> copy = <TypeVariableBuilder>[];
     for (KernelTypeVariableBuilder variable in original) {
       var newVariable = new KernelTypeVariableBuilder(
           variable.name, this, variable.charOffset);
       copy.add(newVariable);
       boundlessTypeVariables.add(newVariable);
     }
     Map<TypeVariableBuilder, TypeBuilder> substitution =
@@ skipping 14 matching lines @@
     for (KernelTypeVariableBuilder builder in boundlessTypeVariables) {
       builder.finish(object);
     }
     boundlessTypeVariables.clear();
     return count;
   }
 
   @override
   void includePart(KernelLibraryBuilder part) {
     super.includePart(part);
+    nativeMethods.addAll(part.nativeMethods);
     boundlessTypeVariables.addAll(part.boundlessTypeVariables);
     mixinApplicationClasses.addAll(part.mixinApplicationClasses);
   }
 }
 
 bool isConstructorName(String name, String className) {
   if (name.startsWith(className)) {
     if (name.length == className.length) return true;
     if (name.startsWith(".", className.length)) return true;
   }
   return false;
 }