Compile and run Hello World!

pkg/compiler/lib/src/ssa/optimize.dart

 // Copyright (c) 2012, 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 '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart' show Selectors;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
@@ skipping 464 matching lines @@
     TypeMask receiverType = node.getDartReceiver(_closedWorld).instructionType;
     MemberEntity element =
         _closedWorld.locateSingleElement(node.selector, receiverType);
     // TODO(ngeoffray): Also fold if it's a getter or variable.
     if (element != null &&
         element.isFunction
         // If we found out that the only target is an implicitly called
         // [:noSuchMethod:] we just ignore it.
         &&
         node.selector.applies(element)) {
-      MethodElement method = element;
+      FunctionEntity method = element;
 
       if (_nativeData.isNativeMember(method)) {
         HInstruction folded = tryInlineNativeMethod(node, method);
         if (folded != null) return folded;
       } else {
         // TODO(ngeoffray): If the method has optional parameters,
         // we should pass the default values.
-        ResolutionFunctionType type = method.type;
-        int optionalParameterCount =
-            type.optionalParameterTypes.length + type.namedParameters.length;
-        if (optionalParameterCount == 0 ||
-            type.parameterTypes.length + optionalParameterCount ==
+        ParameterStructure parameters = method.parameterStructure;
+        if (parameters.optionalParameters == 0 ||
+            parameters.requiredParameters + parameters.optionalParameters ==
                 node.selector.argumentCount) {
           node.element = method;
         }
       }
       return node;
     }
 
     // Replace method calls through fields with a closure call on the value of
     // the field. This usually removes the demand for the call-through stub and
     // makes the field load available to further optimization, e.g. LICM.
@@ skipping 510 matching lines @@
     return new HFieldGet(field, receiver, type, isAssignable: isAssignable);
   }
 
   HInstruction visitInvokeDynamicSetter(HInvokeDynamicSetter node) {
     if (node.isInterceptedCall) {
       HInstruction folded = handleInterceptedCall(node);
       if (folded != node) return folded;
     }
 
     HInstruction receiver = node.getDartReceiver(_closedWorld);
-    FieldElement field =
+    FieldEntity field =
         findConcreteFieldForDynamicAccess(receiver, node.selector);
     if (field == null || !field.isAssignable) return node;
     // Use `node.inputs.last` in case the call follows the interceptor calling
     // convention, but is not a call on an interceptor.
     HInstruction value = node.inputs.last;
     if (_options.enableTypeAssertions) {
-      ResolutionDartType type = field.type;
+      // TODO(johnniwinther): Support field entities.
+      FieldElement element = field;
+      DartType type = element.type;
       if (!type.treatAsRaw ||
           type.isTypeVariable ||
           type.unaliased.isFunctionType) {
         // We cannot generate the correct type representation here, so don't
         // inline this access.
         // TODO(sra): If the input is such that we don't need a type check, we
         // can skip the test an generate the HFieldSet.
         return node;
       }
       HInstruction other = value.convertType(
@@ skipping 1942 matching lines @@
 
     keyedValues.forEach((receiver, values) {
       result.keyedValues[receiver] =
           new Map<HInstruction, HInstruction>.from(values);
     });
 
     result.nonEscapingReceivers.addAll(nonEscapingReceivers);
     return result;
   }
 }