Parse formal parameters.

dart/frog/frogsh

 #!/usr/bin/env node
 //  ********** Library dart:core **************
 //  ********** Natives dart:core **************
 /**
  * Generates a dynamic call stub for a function.
  * Our goal is to create a stub method like this on-the-fly:
  *   function($0, $1, capture) { this($0, $1, true, capture); }
  *
  * This stub then replaces the dynamic one on Function, with one that is
  * specialized for that particular function, taking into account its default
@@ skipping 5174 matching lines @@
 Parser.prototype.parseInterfaceBody = function(token) {
   token = this.skipBlock(token);
   this.listener.endInterface(token);
   return token.next;
 }
 Parser.prototype.parseNamedFunctionAlias = function(token) {
   this.listener.beginFunctionTypeAlias(token);
   token = this.parseReturnTypeOpt(this.next(token));
   token = this.parseIdentifier(token);
   token = this.parseTypeVariablesOpt(token);
-  token = this.parseParameters(token);
+  token = this.parseFormalParameters(token);
   this.listener.endFunctionTypeAlias(token);
   return this.expect(';', token);
 }
 Parser.prototype.parseReturnTypeOpt = function(token) {
   if ($notnull_bool(token.get$stringValue() === 'void')) {
     this.listener.voidType(token);
     return this.next(token);
   }
   else {
     return this.parseTypeOpt(token);
   }
 }
-Parser.prototype.parseParameters = function(token) {
+Parser.prototype.parseFormalParameters = function(token) {
+  var begin = token;
+  this.listener.beginFormalParameters(begin);
   this.expect('(', token);
-  if ($notnull_bool(this.optional(')', this.next(token)))) {
-    return this.next(this.next(token));
+  var parameterCount = 0;
+  if ($notnull_bool(this.optional(')', token.next))) {
+    this.listener.endFormalParameters(parameterCount, begin, token.next);
+    return token.next.next;
   }
   do {
+    this.listener.beginFormalParameter(token);
     token = this.parseTypeOpt(this.next(token));
     token = this.parseIdentifier(token);
+    this.listener.endFormalParameter(token);
+    ++parameterCount;
   }
   while ($notnull_bool(this.optional(',', token)))
+  this.listener.endFormalParameters(parameterCount, begin, token);
   return this.expect(')', token);
 }
 Parser.prototype.parseTypeOpt = function(token) {
   var nextValue = token.next.get$stringValue();
   switch (true) {
     case nextValue === '<':
     case nextValue === '.':
     case this.isIdentifier(token.next):
 
       return this.parseType(token);
 
     default:
 
+      this.listener.handleNoType(token);
       return token;
 
   }
 }
 Parser.prototype.isIdentifier = function(token) {
   var kind = token.kind;
   switch (true) {
     case kind === 97/*null.IDENTIFIER_TOKEN*/:
 
       return true;
@@ skipping 226 matching lines @@
 $inherits(BodyParser, Parser);
 BodyParser.prototype.parseFunction = function(token) {
   this.listener.beginFunction(token);
   token = this.parseReturnTypeOpt(token);
   this.listener.beginFunctionName(token);
   token = this.parseIdentifier(token);
   this.listener.endFunctionName(token);
   token = this.parseFormalParameters(token);
   return this.parseFunctionBody(token);
 }
-BodyParser.prototype.parseFormalParameters = function(token) {
-  var begin = token;
-  this.listener.beginFormalParameters(begin);
-  this.expect('(', token);
-  var parameterCount = 0;
-  if ($notnull_bool(this.optional(')', token.next))) {
-    this.listener.endFormalParameters(parameterCount, begin, token.next);
-    return token.next.next;
-  }
-  do {
-    token = this.parseType(this.next(token));
-    token = this.parseIdentifier(token);
-    ++parameterCount;
-  }
-  while ($notnull_bool(this.optional(',', token)))
-  this.listener.endFormalParameters(parameterCount, begin, token);
-  return this.expect(')', token);
-}
 BodyParser.prototype.parseFunctionBody = function(token) {
   if ($notnull_bool(this.optional(';', token))) {
     this.listener.endFunctionBody(0, null, token);
     return token.next;
   }
   var begin = token;
   var statementCount = 0;
   this.listener.beginFunctionBody(begin);
   token = this.checkEof(this.expect('{', token));
   while ($notnull_bool(!$notnull_bool(this.optional('}', token)))) {
@@ skipping 32 matching lines @@
       return this.parseExpressionStatement(token);
 
   }
 }
 BodyParser.prototype.expectSemicolon = function(token) {
   return this.expect(';', token);
 }
 BodyParser.prototype.parseReturnStatement = function(token) {
   var begin = token;
   this.listener.beginReturnStatement(begin);
-  $assert('return' === token.get$stringValue(), "'return' === token.stringValue", "parser.dart", 409, 12);
+  $assert('return' === token.get$stringValue(), "'return' === token.stringValue", "parser.dart", 399, 12);
   token = this.parseExpression(this.next(token));
   this.listener.endReturnStatement(true, begin, token);
   return this.expectSemicolon(token);
 }
 BodyParser.prototype.parseExpressionStatementOrDeclaration = function(token) {
-  $assert(token.kind === 97/*null.IDENTIFIER_TOKEN*/, "token.kind === IDENTIFIER_TOKEN", "parser.dart", 416, 12);
+  $assert(token.kind === 97/*null.IDENTIFIER_TOKEN*/, "token.kind === IDENTIFIER_TOKEN", "parser.dart", 406, 12);
   var peek1 = this.next(token);
   if ($notnull_bool(peek1.kind === 97/*null.IDENTIFIER_TOKEN*/)) {
     return this.parseLocalDeclaration(token, peek1);
   }
   else {
     return this.parseExpressionStatement(token);
   }
 }
 BodyParser.prototype.parseLocalDeclaration = function(token, peek1) {
   var peek2 = this.next(peek1);
@@ skipping 28 matching lines @@
     var question = token;
     token = this.parseExpression(this.next(token));
     var colon = token;
     token = this.expect(':', token);
     token = this.parseExpression(token);
     this.listener.handleConditionalExpression(question, colon);
   }
   return token;
 }
 BodyParser.prototype.parseBinaryExpression = function(token, precedence) {
-  $assert(precedence >= 4, "precedence >= 4", "parser.dart", 469, 12);
+  $assert(precedence >= 4, "precedence >= 4", "parser.dart", 459, 12);
   token = this.parsePrimary(token);
   var tokenLevel = this.getPrecedence(token);
   for (var level = tokenLevel;
    $notnull_bool(level >= precedence); --level) {
     while ($notnull_bool(tokenLevel === level)) {
       var operator = token;
       token = this.parseBinaryExpression(this.next(token), level + 1);
       this.listener.handleBinaryExpression(operator);
       tokenLevel = this.getPrecedence(token);
     }
@@ skipping 244 matching lines @@
     this.listener.handleNoArguments(token);
     return token;
   }
   else {
     return this.parseArguments(token);
   }
 }
 BodyParser.prototype.parseArguments = function(token) {
   var begin = token;
   this.listener.beginArguments(begin);
-  $assert('(' === token.get$stringValue(), "'(' === token.stringValue", "parser.dart", 602, 12);
+  $assert('(' === token.get$stringValue(), "'(' === token.stringValue", "parser.dart", 592, 12);
   var argumentCount = 0;
   if ($notnull_bool(this.optional(')', token.next))) {
     this.listener.endArguments(argumentCount, begin, token.next);
     return token.next.next;
   }
   do {
     token = this.parseExpression(this.next(token));
     ++argumentCount;
   }
   while ($notnull_bool(this.optional(',', token)))
@@ skipping 100 matching lines @@
 }
 Listener.prototype.endClass = function(token) {
 
 }
 Listener.prototype.beginExpressionStatement = function(token) {
 
 }
 Listener.prototype.endExpressionStatement = function(token) {
 
 }
+Listener.prototype.beginFormalParameter = function(token) {
+
+}
+Listener.prototype.endFormalParameter = function(token) {
+
+}
 Listener.prototype.beginFormalParameters = function(token) {
 
 }
 Listener.prototype.endFormalParameters = function(count, beginToken, endToken) {
 
 }
 Listener.prototype.beginFunction = function(token) {
 
 }
 Listener.prototype.beginFunctionBody = function(token) {
@@ skipping 100 matching lines @@
 }
 Listener.prototype.handleLiteralInt = function(token) {
 
 }
 Listener.prototype.handleLiteralString = function(token) {
 
 }
 Listener.prototype.handleNoArguments = function(token) {
 
 }
+Listener.prototype.handleNoType = function(token) {
+
+}
 Listener.prototype.handleNoTypeVariables = function(token) {
 
 }
 Listener.prototype.handleVarKeyword = function(token) {
 
 }
 Listener.prototype.identifier = function(token) {
 
 }
 Listener.prototype.topLevelField = function(token) {
@@ skipping 158 matching lines @@
 }
 // ********** Code for BodyListener **************
 function BodyListener(canceler, logger) {
   this.nodes = const$228/*const EmptyLink<DeclarationBuilder>()*/
   this.logger = logger;
   ElementListener.call(this, canceler);
   // Initializers done
   this.onError = this.get$handleOnError();
 }
 $inherits(BodyListener, ElementListener);
+BodyListener.prototype.endFormalParameter = function(token) {
+  var name = new NodeList.singleton$ctor(this.popNode());
+  var type = this.popNode();
+  this.pushNode(new VariableDefinitions(type, null, name, token));
+}
 BodyListener.prototype.endFormalParameters = function(count, beginToken, endToken) {
   this.pushNode(this.makeNodeList(count, beginToken, endToken, ","));
 }
 BodyListener.prototype.endArguments = function(count, beginToken, endToken) {
   this.pushNode(this.makeNodeList(count, beginToken, endToken, ","));
 }
 BodyListener.prototype.handleNoArguments = function(token) {
   this.pushNode(null);
 }
 BodyListener.prototype.endReturnStatement = function(hasExpression, beginToken, endToken) {
@@ skipping 88 matching lines @@
   var $0;
   this.pushNode(new TypeAnnotation((($0 = this.popNode()) && $0.is$Identifier())));
 }
 BodyListener.prototype.pushNode = function(node) {
   var $0;
   this.nodes = (($0 = this.nodes.prepend(node)) && $0.is$Link$Node());
   this.logger.log(("push " + this.nodes + ""));
 }
 BodyListener.prototype.popNode = function() {
   var $0;
-  $assert(!$notnull_bool(this.nodes.isEmpty()), "!nodes.isEmpty()", "listener.dart", 510, 12);
+  $assert(!$notnull_bool(this.nodes.isEmpty()), "!nodes.isEmpty()", "listener.dart", 525, 12);
   var node = this.nodes.get$head();
   this.nodes = (($0 = this.nodes.get$tail()) && $0.is$Link$Node());
   this.logger.log(("pop " + this.nodes + ""));
   return node;
 }
 BodyListener.prototype.makeNodeList = function(count, beginToken, endToken, delimiter) {
   var $0;
   var nodes = const$228/*const EmptyLink<DeclarationBuilder>()*/;
   for (; $notnull_bool(count > 0); --count) {
     nodes = (($0 = nodes.prepend(this.popNode())) && $0.is$Link$Node());
@@ skipping 593 matching lines @@
 }
 // ********** Code for Operator **************
 function Operator(token) {
   Identifier.call(this, token);
   // Initializers done
 }
 $inherits(Operator, Identifier);
 Operator.prototype.accept = function(visitor) {
   return visitor.visitOperator(this);
 }
-// ********** Code for Parameter **************
-function Parameter() {}
-$inherits(Parameter, Node);
-Parameter.prototype.get$name = function() { return this.name; };
-Parameter.prototype.accept = function(visitor) {
-  return visitor.visitParameter(this);
-}
-Parameter.prototype.getBeginToken = function() {
-  return firstBeginToken(this.typeAnnotation, this.name);
-}
-Parameter.prototype.getEndToken = function() {
-  return this.name.getEndToken();
-}
 // ********** Code for Return **************
 function Return(beginToken, endToken, expression) {
   this.beginToken = beginToken;
   this.endToken = endToken;
   this.expression = expression;
   // Initializers done
 }
 $inherits(Return, Statement);
 Return.prototype.get$hasExpression = function() {
   return this.expression != null;
@@ skipping 123 matching lines @@
       if ($notnull_bool(!$notnull_bool(first))) delimiter.printOn(this.sb);
       first = false;
       this.visit(element);
     }
   }
   if ($notnull_bool(node.endToken != null)) this.sb.add(node.endToken);
 }
 DebugUnparser.prototype.visitOperator = function(node) {
   this.visitIdentifier(node);
 }
-DebugUnparser.prototype.visitParameter = function(node) {
-  if ($notnull_bool(node.typeAnnotation != null)) {
-    this.visit(node.typeAnnotation);
-    this.sb.add(' ');
-  }
-  this.visit(node.name);
-}
 DebugUnparser.prototype.visitReturn = function(node) {
   node.beginToken.get$value().printOn$1(this.sb);
   if ($notnull_bool(node.get$hasExpression())) {
     this.sb.add(' ');
     this.visit(node.expression);
   }
   node.endToken.get$value().printOn$1(this.sb);
 }
 DebugUnparser.prototype.visitSend = function(node) {
   if ($notnull_bool(node.receiver != null)) {
@@ skipping 49 matching lines @@
   var $0;
   if ($notnull_bool(this.type != null)) return this.type;
   var node = this.parseNode(compiler, compiler);
   var returnType = getType(node.returnType, types);
   if ($notnull_bool(returnType == null)) compiler.cancel(('unknown type ' + returnType + ''));
   var parameterTypes = new LinkBuilderImplementation$Type();
   for (var link = node.parameters.nodes;
    $notnull_bool(!$notnull_bool(link.isEmpty())); link = link.get$tail()) {
     compiler.cancel('parameters not supported.');
     var parameter = link.get$head();
-    parameterTypes.addLast(getType(parameter.typeAnnotation, types));
+    parameterTypes.addLast(getType(parameter.type, types));
   }
   this.type = new FunctionType(returnType, (($0 = parameterTypes.toLink()) && $0.is$Link$Type()));
   return this.type;
 }
 // ********** Code for top level **************
 function getType(annotation, types) {
   if ($notnull_bool(annotation == null || annotation.typeName == null)) {
     return types.get$dynamic();
   }
   return types.lookup(annotation.typeName.get$source());
@@ skipping 142 matching lines @@
 SsaBuilder.prototype.visitNodeList = function(node) {
   var $0;
   for (var link = node.nodes;
    $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
     this.visit((($0 = link.get$head()) && $0.is$Node()));
   }
 }
 SsaBuilder.prototype.visitOperator = function(node) {
   this.compiler.unimplemented("SsaBuilder.visitOperator");
 }
-SsaBuilder.prototype.visitParameter = function(node) {
-  this.compiler.unimplemented("SsaBuilder.visitParameter");
-}
 SsaBuilder.prototype.visitReturn = function(node) {
   this.visit(node.expression);
   var value = this.pop();
   this.add(new HReturn(value));
   this.graph.setSuccessors(this.block, [this.graph.exit]);
 }
 SsaBuilder.prototype.visitTypeAnnotation = function(node) {
 
 }
 SsaBuilder.prototype.updateDefinition = function(node) {
   var $0;
   if ($notnull_bool(node.receiver != null)) {
     this.compiler.unimplemented("SsaBuilder: property access");
   }
   var link = node.get$arguments();
-  $assert(!$notnull_bool(link.isEmpty()) && link.get$tail().isEmpty(), "!link.isEmpty() && link.tail.isEmpty()", "builder.dart", 197, 12);
+  $assert(!$notnull_bool(link.isEmpty()) && link.get$tail().isEmpty(), "!link.isEmpty() && link.tail.isEmpty()", "builder.dart", 193, 12);
   this.visit((($0 = link.get$head()) && $0.is$Node()));
   var value = this.pop();
   return this.definitions.$setindex(this.elements.$index(node), value);
 }
 SsaBuilder.prototype.visitVariableDefinitions = function(node) {
   var $0;
   for (var link = node.definitions.nodes;
    $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
     var definition = link.get$head();
     if ($notnull_bool((definition instanceof Identifier))) {
       this.compiler.unimplemented("SsaBuilder.visitVariableDefinitions without initial value");
     }
     else {
-      $assert((definition instanceof SendSet), "definition is SendSet", "builder.dart", 212, 16);
+      $assert((definition instanceof SendSet), "definition is SendSet", "builder.dart", 208, 16);
       this.updateDefinition((definition && definition.is$SendSet()));
     }
   }
 }
 // ********** Code for SsaCodeGeneratorTask **************
 function SsaCodeGeneratorTask(compiler) {
   CompilerTask.call(this, compiler);
   // Initializers done
 }
 $inherits(SsaCodeGeneratorTask, CompilerTask);
@@ skipping 1642 matching lines @@
 TypeCheckerVisitor.prototype.visitNodeList = function(node) {
   var $0;
   for (var link = node.nodes;
    $notnull_bool(!$notnull_bool(link.isEmpty())); link = (($0 = link.get$tail()) && $0.is$Link$Node())) {
     this.type((($0 = link.get$head()) && $0.is$Node()));
   }
 }
 TypeCheckerVisitor.prototype.visitOperator = function(node) {
   return this.types.dynamicType;
 }
-TypeCheckerVisitor.prototype.visitParameter = function(node) {
-  return null;
-}
 TypeCheckerVisitor.prototype.checkAssignable = function(node, s, t) {
   if ($notnull_bool(!$notnull_bool(this.types.isAssignable(s, t)))) {
     var error = CompilerError.notAssignable(s, t);
     this.compiler.reportWarning(node, error);
   }
 }
 TypeCheckerVisitor.prototype.visitReturn = function(node) {
   var expressionType = this.type(node.expression);
   this.checkAssignable(node, this.expectedReturnType, expressionType);
   return this.types.voidType;
@@ skipping 845 matching lines @@
       }
       if ($notnull_bool(!$notnull_bool(field.get$isField()))) {
         world.error(('"this.' + p.get$name() + '" does not refer to a field'), p.get$definition().get$span());
       }
       var paramValue = new Value(field.get$returnType(), p.get$name(), false, false, false);
       this._paramCode.add(paramValue.code);
       initializers.add(('this.' + field.get$jsname() + ' = ' + paramValue.code + ';'));
       initializedFields.add(p.get$name());
     }
     else {
-      var paramValue = this._scope.declareParameter((p && p.is$lang_Parameter()));
+      var paramValue = this._scope.declareParameter((p && p.is$Parameter()));
       this._paramCode.add(paramValue.code);
     }
   }
   var body = this.method.get$definition().body;
   if ($notnull_bool(body == null && !$notnull_bool(this.method.get$isConstructor()))) {
     world.error(('unexpected empty body for ' + this.method.name + ''), this.method.get$definition().get$span());
   }
   if ($notnull_bool($ne(initializers, null))) {
     for (var $i = initializers.iterator(); $i.hasNext(); ) {
       var i = $i.next();
@@ skipping 1552 matching lines @@
 _LibraryVisitor.prototype.visitVariableDefinition = function(node) {
   this.currentType.addField(node);
 }
 _LibraryVisitor.prototype.visitFunctionDefinition = function(node) {
   this.currentType.addMethod(node.name.name, node);
 }
 _LibraryVisitor.prototype.visitFunctionTypeDefinition = function(node) {
   var type = this.library.addType(node.func.name.name, node, false);
   type.addMethod('\$call', node.func);
 }
-// ********** Code for lang_Parameter **************
-function lang_Parameter(definition) {
+// ********** Code for Parameter **************
+function Parameter(definition) {
   this.isInitializer = false
   this.definition = definition;
   // Initializers done
 }
-lang_Parameter.prototype.is$lang_Parameter = function(){return this;};
-lang_Parameter.prototype.get$definition = function() { return this.definition; };
-lang_Parameter.prototype.set$definition = function(value) { return this.definition = value; };
-lang_Parameter.prototype.get$name = function() { return this.name; };
-lang_Parameter.prototype.set$name = function(value) { return this.name = value; };
-lang_Parameter.prototype.get$value = function() { return this.value; };
-lang_Parameter.prototype.set$value = function(value) { return this.value = value; };
-lang_Parameter.prototype.resolve = function(method, inType) {
+Parameter.prototype.is$Parameter = function(){return this;};
+Parameter.prototype.get$definition = function() { return this.definition; };
+Parameter.prototype.set$definition = function(value) { return this.definition = value; };
+Parameter.prototype.get$name = function() { return this.name; };
+Parameter.prototype.set$name = function(value) { return this.name = value; };
+Parameter.prototype.get$value = function() { return this.value; };
+Parameter.prototype.set$value = function(value) { return this.value = value; };
+Parameter.prototype.resolve = function(method, inType) {
   this.name = this.definition.name.name;
   if ($notnull_bool(this.name.startsWith('this.'))) {
     this.name = this.name.substring(5);
     this.isInitializer = true;
   }
   this.type = inType.resolveType(this.definition.type, false);
   if ($notnull_bool(method.get$isStatic() && this.type.get$hasTypeParams())) {
     world.error('using type parameter in static context', this.definition.span);
   }
   if ($notnull_bool(this.definition.value != null)) {
     if ($notnull_bool((this.definition.value instanceof NullExpression) && this.definition.value.span.start == this.definition.span.start)) {
       return;
     }
     if ($notnull_bool(method.get$isAbstract())) {
       world.error('default value not allowed on abstract methods', this.definition.span);
     }
     else if ($notnull_bool(method.name == '\$call' && method.get$definition().body == null)) {
       world.error('default value not allowed on function type', this.definition.span);
     }
   }
   else if ($notnull_bool(this.isInitializer && !$notnull_bool(method.get$isConstructor()))) {
     world.error('initializer parameters only allowed on constructors', this.definition.span);
   }
 }
-lang_Parameter.prototype.genValue = function(method, context) {
+Parameter.prototype.genValue = function(method, context) {
   var $0;
   if ($notnull_bool(this.definition.value == null || this.value != null)) return;
   if ($notnull_bool(context == null)) {
     context = new MethodGenerator(method, null);
   }
   this.value = (($0 = this.definition.value.visit(context)) && $0.is$Value());
   this.value = this.value.convertTo(context, this.type, this.definition.value, false);
 }
-lang_Parameter.prototype.copyWithNewType = function(newType) {
-  var ret = new lang_Parameter(this.definition);
+Parameter.prototype.copyWithNewType = function(newType) {
+  var ret = new Parameter(this.definition);
   ret.type = newType;
   ret.name = this.name;
   ret.isInitializer = this.isInitializer;
   return ret;
 }
-lang_Parameter.prototype.get$isOptional = function() {
+Parameter.prototype.get$isOptional = function() {
   return this.definition != null && this.definition.value != null;
 }
 // ********** Code for Member **************
 function Member(name, declaringType) {
   this.name = name;
   this.declaringType = declaringType;
   this.isGenerated = false;
   // Initializers done
 }
 Member.prototype.is$Member = function(){return this;};
@@ skipping 1173 matching lines @@
   else {
     this.returnType = inType.resolveType(this.definition.returnType, false);
     if ($notnull_bool(this.isStatic && this.returnType.get$hasTypeParams())) {
       world.error('using type parameter in static context', this.definition.returnType.span);
     }
   }
   this.parameters = [];
   var $list = this.definition.formals;
   for (var $i = 0;$i < $list.length; $i++) {
     var formal = $list.$index($i);
-    var param = new lang_Parameter(formal);
+    var param = new Parameter(formal);
     param.resolve(this, inType);
     this.parameters.add(param);
   }
   if ($notnull_bool(!$notnull_bool(this.isLambda))) {
     this.get$library()._addMember(this);
   }
 }
 MethodMember.prototype.get_$3 = function($0, $1, $2) {
   return this.get_(($0 && $0.is$MethodGenerator()), ($1 && $1.is$lang_Node()), ($2 && $2.is$Value()), false);
 }
@@ skipping 6625 matching lines @@
       INTERFACE,
       LIBRARY,
       NATIVE,
       NEGATE,
       OPERATOR,
       SET,
       SOURCE,
       STATIC,
       TYPEDEF ]*/;
 RunEntry(function () {main();}, []);