Fasta kernel builders.

pkg/fasta/lib/src/kernel/kernel_class_builder.dart

Index: pkg/fasta/lib/src/kernel/kernel_class_builder.dart
diff --git a/pkg/fasta/lib/src/kernel/kernel_class_builder.dart b/pkg/fasta/lib/src/kernel/kernel_class_builder.dart
new file mode 100644
index 0000000000000000000000000000000000000000..6b0524d736e3c5209b593bf474ff7180d2acc078
--- /dev/null
+++ b/pkg/fasta/lib/src/kernel/kernel_class_builder.dart
@@ -0,0 +1,118 @@
+// 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_class_builder;
+
+import 'package:kernel/ast.dart' show
+    Class,
+    DartType,
+    ExpressionStatement,
+    InterfaceType,
+    Member,
+    StringLiteral,
+    Supertype,
+    Throw;
+
+import '../errors.dart' show
+    internalError;
+
+import 'kernel_builder.dart' show
+    Builder,
+    ClassBuilder,
+    ConstructorReferenceBuilder,
+    KernelProcedureBuilder,
+    KernelTypeBuilder,
+    LibraryBuilder,
+    MetadataBuilder,
+    ProcedureBuilder,
+    TypeVariableBuilder,
+    computeDefaultTypeArguments;
+
+import 'redirecting_factory_body.dart' show
+    RedirectingFactoryBody;
+
+abstract class KernelClassBuilder
+    extends ClassBuilder<KernelTypeBuilder, InterfaceType> {
+  KernelClassBuilder(
+      List<MetadataBuilder> metadata, int modifiers,
+      String name, List<TypeVariableBuilder> typeVariables,
+      KernelTypeBuilder supertype, List<KernelTypeBuilder> interfaces,
+      Map<String, Builder> members, List<KernelTypeBuilder> types,
+      LibraryBuilder parent)
+      : super(metadata, modifiers, name, typeVariables, supertype, interfaces,
+          members, types, parent);
+
+  Class get cls;
+
+  Class get target => cls;
+
+  /// [arguments] have already been built.
+  InterfaceType buildTypesWithBuiltArguments(List<DartType> arguments) {
+    return arguments == null
+        ? cls.rawType
+        : new InterfaceType(cls,
+            computeDefaultTypeArguments(cls.typeParameters, arguments));

[Johnni Winther, 2017/01/18 12:42:39]

Why do we allow discrepancies and effective treat `Map<String>` as `Map<String,
dynamic>` ?

[ahe, 2017/01/18 15:21:50]

We need to do something, and I'm not sure what the right thing to do is. I've
added a TODO stating this.

+  }
+
+  InterfaceType buildType(List<KernelTypeBuilder> arguments) {
+    List<DartType> typeArguments;
+    if (arguments != null) {
+      typeArguments = <DartType>[];
+      for (KernelTypeBuilder builder in arguments) {
+        DartType type = builder.build();
+        if (type == null) {
+          internalError("Bad type: ${builder.runtimeType}");
+        }
+        typeArguments.add(type);
+      }
+    }
+    return buildTypesWithBuiltArguments(typeArguments);
+  }
+
+  Supertype buildSupertype(List<KernelTypeBuilder> arguments) {
+    List<DartType> typeArguments;
+    if (arguments != null) {
+      typeArguments = <DartType>[];
+      for (KernelTypeBuilder builder in arguments) {
+        DartType type = builder.build();
+        if (type == null) {
+          internalError("Bad type: ${builder.runtimeType}");
+        }
+        typeArguments.add(type);
+      }
+      return new Supertype(cls, typeArguments);
+    } else {
+      return cls.asRawSupertype;
+    }
+  }
+
+  int resolveConstructors(LibraryBuilder library) {
+    int count = super.resolveConstructors(library);
+    if (count != 0) {
+      members.forEach((String name, Builder builder) {
+        if (builder is KernelProcedureBuilder && builder.isFactory) {
+          ConstructorReferenceBuilder redirectionTarget =
+              builder.redirectionTarget;
+          if (redirectionTarget != null) {
+            assert(builder.actualBody == null);
+            Builder targetBuilder = redirectionTarget.target;
+            if (targetBuilder is ProcedureBuilder) {
+              Member target = targetBuilder.target;

[Johnni Winther, 2017/01/18 12:42:39]

Does this handle multiple steps (is .target the effective or immediate target):

class A {}
class B implements A { factory B = A; }
class C implements B { factory C = B; }

[ahe, 2017/01/18 15:21:50]

It computes the immediate target. Added a comment about that.

It would require another phase to compute the effective target.

+              builder.body = new RedirectingFactoryBody(target);
+            } else {
+              // TODO(ahe): Throw NSM error. This requires access to core
+              // types.
+              String message =
+                  "Missing constructor: ${redirectionTarget.fullNameForErrors}";
+              print(message);
+              builder.body = new ExpressionStatement(
+                  new Throw(new StringLiteral(message)));
+            }
+          }
+        }
+      });
+    }
+    return count;
+  }
+}