Introduce ParameterStructure

pkg/compiler/lib/src/kernel/world_builder.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.world_builder;
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/backend_api.dart';
@@ skipping 175 matching lines @@
             return _getTypeVariable(cls.typeParameters[index]);
           } else {
             return new KTypeVariable(_getMethod(procedure), node.name, index);
           }
         }
       }
       throw new UnsupportedError('Unsupported type parameter type node $node.');
     });
   }
 
+  ParameterStructure _getParameterStructure(ir.FunctionNode node) {
+    // TODO(johnniwinther): Cache the computed function type.
+    int requiredParameters = node.requiredParameterCount;
+    int positionalParameters = node.positionalParameters.length;
+    List<String> namedParameters =
+        node.namedParameters.map((p) => p.name).toList()..sort();
+    return new ParameterStructure(
+        requiredParameters, positionalParameters, namedParameters);
+  }
+
   KConstructor _getConstructor(ir.Member node) {
     return _constructorMap.putIfAbsent(node, () {
       int memberIndex = _memberList.length;
       KConstructor constructor;
       KClass enclosingClass = _getClass(node.enclosingClass);
       Name name = getName(node.name);
       bool isExternal = node.isExternal;
+
       if (node is ir.Constructor) {
-        constructor = new KGenerativeConstructor(
-            memberIndex, enclosingClass, name,
+        constructor = new KGenerativeConstructor(memberIndex, enclosingClass,
+            name, _getParameterStructure(node.function),
             isExternal: isExternal, isConst: node.isConst);
       } else if (node is ir.Procedure) {
         constructor = new KFactoryConstructor(memberIndex, enclosingClass, name,
+            _getParameterStructure(node.function),
             isExternal: isExternal, isConst: node.isConst);
       } else {
         // TODO(johnniwinther): Convert `node.location` to a [SourceSpan].
         throw new SpannableAssertionFailure(
             NO_LOCATION_SPANNABLE, "Unexpected constructor node: ${node}.");
       }
       _memberList.add(node);
       return constructor;
     });
   }
@@ skipping 19 matching lines @@
           throw new UnsupportedError("Cannot create method from factory.");
         case ir.ProcedureKind.Getter:
           function = new KGetter(memberIndex, library, enclosingClass, name,
               isStatic: isStatic,
               isExternal: isExternal,
               isAbstract: isAbstract);
           break;
         case ir.ProcedureKind.Method:
         case ir.ProcedureKind.Operator:
           function = new KMethod(memberIndex, library, enclosingClass, name,
+              _getParameterStructure(node.function),
               isStatic: isStatic,
               isExternal: isExternal,
               isAbstract: isAbstract);
           break;
         case ir.ProcedureKind.Setter:
           function = new KSetter(
               memberIndex, library, enclosingClass, getName(node.name).setter,
               isStatic: isStatic,
               isExternal: isExternal,
               isAbstract: isAbstract);
@@ skipping 656 matching lines @@
   }
 
   InterfaceType getMixinTypeForClass(KClass cls) {
     KClassEnv env = builder._classEnvs[cls.classIndex];
     ir.Supertype mixedInType = env.cls.mixedInType;
     if (mixedInType == null) return null;
     return builder.createInterfaceType(
         mixedInType.classNode, mixedInType.typeArguments);
   }
 }