Towards compiling Hello World!

pkg/compiler/lib/src/kernel/element_map_impl.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.
 
 library dart2js.kernel.element_map;
 
 import 'package:kernel/ast.dart' as ir;
 import 'package:kernel/clone.dart';
 import 'package:kernel/type_algebra.dart';
 
@@ skipping 123 matching lines @@
   native.BehaviorBuilder get nativeBehaviorBuilder => _nativeBehaviorBuilder;
 
   @override
   ConstantValue computeConstantValue(ConstantExpression constant,
       {bool requireConstant: true}) {
     return _constantEnvironment.getConstantValue(constant);
   }
 
   @override
   ConstantValue getFieldConstantValue(ir.Field field) {
+    // TODO(johnniwinther): Cache the result in [_FieldData].
     return getConstantValue(field.initializer, requireConstant: field.isConst);
   }
 
   LibraryEntity lookupLibrary(Uri uri) {
     _KLibraryEnv libraryEnv = _env.lookupLibrary(uri);
     if (libraryEnv == null) return null;
     return _getLibrary(libraryEnv.library, libraryEnv);
   }
 
   KLibrary _getLibrary(ir.Library node, [_KLibraryEnv libraryEnv]) {
@@ skipping 512 matching lines @@
 
   @override
   Local getLocalFunction(ir.TreeNode node) => _getLocal(node);
 
   @override
   ClassEntity getClass(ir.Class node) => _getClass(node);
 
   @override
   FieldEntity getField(ir.Field node) => _getField(node);
 
+  bool hasConstantFieldInitializer(KField field) {
+    _FieldData data = _memberList[field.memberIndex];
+    return getFieldConstantValue(data.node) != null;
+  }
+
   TypeVariableEntity getTypeVariable(ir.TypeParameter node) =>
       _getTypeVariable(node);
 
   @override
   FunctionEntity getMethod(ir.Procedure node) => _getMethod(node);
 
+  void forEachParameter(KFunction function,
+      void f(DartType type, String name, ConstantValue defaultValue)) {
+    _FunctionData data = _memberList[function.memberIndex];
+    data.forEachParameter(this, f);
+  }
+
   @override
   MemberEntity getMember(ir.Member node) {
     if (node is ir.Field) {
       return _getField(node);
     } else if (node is ir.Constructor) {
       return _getConstructor(node);
     } else if (node is ir.Procedure) {
       if (node.kind == ir.ProcedureKind.Factory) {
         return _getConstructor(node);
       } else {
@@ skipping 367 matching lines @@
 
 class _FunctionData extends _MemberData {
   final ir.FunctionNode functionNode;
   FunctionType _type;
 
   _FunctionData(ir.Member node, this.functionNode) : super(node);
 
   FunctionType getFunctionType(KernelToElementMapImpl elementMap) {
     return _type ??= elementMap.getFunctionType(functionNode);
   }
+
+  void forEachParameter(KernelToElementMap elementMap,
+      void f(DartType type, String name, ConstantValue defaultValue)) {
+    void handleParameter(ir.VariableDeclaration node, {bool isOptional: true}) {
+      DartType type = elementMap.getDartType(node.type);
+      String name = node.name;
+      ConstantValue defaultValue;
+      if (isOptional) {
+        if (node.initializer != null) {
+          defaultValue = elementMap.getConstantValue(node.initializer);
+        } else {
+          defaultValue = new NullConstantValue();
+        }
+      }
+      f(type, name, defaultValue);
+    }
+
+    for (int i = 0; i < functionNode.positionalParameters.length; i++) {
+      handleParameter(functionNode.positionalParameters[i],
+          isOptional: i < functionNode.requiredParameterCount);
+    }
+    functionNode.namedParameters.forEach(handleParameter);
+  }
 }
 
 class _ConstructorData extends _FunctionData {
   ConstantConstructor _constantConstructor;
 
   _ConstructorData(ir.Member node, ir.FunctionNode functionNode)
       : super(node, functionNode);
 
   ConstantConstructor getConstructorConstant(
       KernelToElementMapImpl elementMap, KConstructor constructor) {
@@ skipping 619 matching lines @@
     return node.isExternal &&
         !elementMap.isForeignLibrary(node.enclosingLibrary);
   }
 
   @override
   bool isJsInteropMember(MemberEntity element) {
     // TODO(johnniwinther): Compute this.
     return false;
   }
 }