Handler the last native annotations

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

 // Copyright (c) 2017, 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.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart';
 import '../constants/constructors.dart';
 import '../constants/expressions.dart';
@@ skipping 185 matching lines @@
   Selector getSetterSelector(ir.Name irName) {
     Name name = new Name(
         irName.name, irName.isPrivate ? getLibrary(irName.library) : null);
     return new Selector.setter(name);
   }
 
   /// Converts [annotations] into a list of [ConstantExpression]s.
   List<ConstantExpression> getMetadata(List<ir.Expression> annotations) {
     List<ConstantExpression> metadata = <ConstantExpression>[];
     annotations.forEach((ir.Expression node) {
-      ConstantExpression constant = node.accept(new Constantifier(this));
+      ConstantExpression constant = new Constantifier(this).visit(node);
       if (constant == null) {
         throw new UnsupportedError(
             'No constant for ${DebugPrinter.prettyPrint(node)}');
       }
       metadata.add(constant);
     });
     return metadata;
   }
 
   /// Returns `true` is [node] has a `@Native(...)` annotation.
@@ skipping 49 matching lines @@
                 : elementEnvironment.getThisType(cls);
           }
         }
         return null;
       }
 
       DartType type = findIn(Uris.dart_core);
       type ??= findIn(BackendHelpers.DART_JS_HELPER);
       type ??= findIn(BackendHelpers.DART_INTERCEPTORS);
       type ??= findIn(BackendHelpers.DART_ISOLATE_HELPER);
+      type ??= findIn(Uris.dart__native_typed_data);
       type ??= findIn(Uris.dart_collection);
+      type ??= findIn(Uris.dart_math);
       type ??= findIn(Uris.dart_html);
+      type ??= findIn(Uris.dart_html_common);
       type ??= findIn(Uris.dart_svg);
       type ??= findIn(Uris.dart_web_audio);
       type ??= findIn(Uris.dart_web_gl);
+      type ??= findIn(Uris.dart_web_sql);

[Siggi Cherem (dart-lang), 2017/02/10 23:00:54]

It would be nice if we could make the sequence of lookups more direct/narrow
depending on the library that contains them.

For example, do we ever have a reference from web_sql to something in svg? If
not, maybe we don't need to do the lookup there in that case.

We could encode this in a map:
Uri (library) => List<Uri> (list of libraries where to do lookup, in order of
likelyhood)

but eventually we could also derive such much from the import graph.

Thoughts? Maybe add a TODO?

[Johnni Winther, 2017/02/12 09:51:49]

Add a TODO.

+      type ??= findIn(Uris.dart_indexed_db);
+      type ??= findIn(Uris.dart_typed_data);
       if (type == null && required) {
         reporter.reportErrorMessage(CURRENT_ELEMENT_SPANNABLE,
             MessageKind.GENERIC, {'text': "Type '$typeName' not found."});
       }
       return type;
     }
 
     return lookup;
   }
 
@@ skipping 156 matching lines @@
       if (value == null) return null;
       sb.write(value);
     }
     return sb.toString();
   }
 }
 
 /// Visitor that converts a kernel constant expression into a
 /// [ConstantExpression].
 class Constantifier extends ir.ExpressionVisitor<ConstantExpression> {
+  final bool requireConstant;
   final KernelElementAdapter elementAdapter;
 
-  Constantifier(this.elementAdapter);
+  Constantifier(this.elementAdapter, {this.requireConstant: true});
+
+  ConstantExpression visit(ir.Expression node) {
+    ConstantExpression constant = node.accept(this);
+    if (constant == null && requireConstant) {
+      throw new UnsupportedError(
+          "No constant computed for $node (${node.runtimeType})");
+    }
+    return constant;
+  }
 
   ConstantExpression defaultExpression(ir.Expression node) {
     throw new UnimplementedError(
         'Unimplemented constant expression $node (${node.runtimeType})');
   }
 
   List<ConstantExpression> _computeList(List<ir.Expression> expressions) {
     List<ConstantExpression> list = <ConstantExpression>[];
     for (ir.Expression expression in expressions) {
-      ConstantExpression constant = expression.accept(this);
+      ConstantExpression constant = visit(expression);
       if (constant == null) return null;
       list.add(constant);
     }
     return list;
   }
 
   List<ConstantExpression> _computeArguments(ir.Arguments node) {
     List<ConstantExpression> arguments = <ConstantExpression>[];
     for (ir.Expression argument in node.positional) {
-      ConstantExpression constant = argument.accept(this);
+      ConstantExpression constant = visit(argument);
       if (constant == null) return null;
       arguments.add(constant);
     }
     for (ir.NamedExpression argument in node.named) {
-      ConstantExpression constant = argument.value.accept(this);
+      ConstantExpression constant = visit(argument.value);
       if (constant == null) return null;
       arguments.add(constant);
     }
     return arguments;
   }
 
   ConstructedConstantExpression _computeConstructorInvocation(
       ir.Constructor target, ir.Arguments arguments) {
     return new ConstructedConstantExpression(
         elementAdapter.createInterfaceType(
@@ skipping 45 matching lines @@
     assert(node.isConst);
     ir.Class cls = node.enclosingClass;
     InterfaceType type = elementAdapter.elementEnvironment
         .getThisType(elementAdapter.getClass(cls));
 
     Map<dynamic, ConstantExpression> defaultValues =
         <dynamic, ConstantExpression>{};
     int parameterIndex = 0;
     node.function.positionalParameters
         .forEach((ir.VariableDeclaration parameter) {
-      if (parameter.initializer != null) {
-        defaultValues[parameterIndex] = parameter.initializer.accept(this);
+      if (parameterIndex >= node.function.requiredParameterCount) {
+        if (parameter.initializer != null) {
+          defaultValues[parameterIndex] = parameter.initializer.accept(this);
+        } else {
+          defaultValues[parameterIndex] = new NullConstantExpression();
+        }
       }
       parameterIndex++;
     });
     node.function.namedParameters.forEach((ir.VariableDeclaration parameter) {
       defaultValues[parameter.name] = parameter.initializer.accept(this);
     });
 
     bool isRedirecting = node.initializers.length == 1 &&
         node.initializers.single is ir.RedirectingInitializer;
 
@@ skipping 29 matching lines @@
     }
     if (isRedirecting) {
       return new RedirectingGenerativeConstantConstructor(
           defaultValues, superConstructorInvocation);
     } else {
       return new GenerativeConstantConstructor(
           type, defaultValues, fieldMap, superConstructorInvocation);
     }
   }
 }