Implemented proposed syntax change for procedur...

Implemented proposed syntax change for procedures (so we can try it out;
it's not committed yet).

3 files changed, 46 insertions, 26 deletions

diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
index dac4832019..5b0cdab181 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
@@ -509,9 +509,10 @@ trait Parsers requires SyntaxAnalyzer {
     }
 
     /** Type ::= Type1 `=>' Type
-    *         | `(' [Types] `)' `=>' Type
-    *         | Type1
-    */
+     *         | `(' `=>' Type `)' `=>' Type
+     *         | `(' [Types] `)' `=>' Type
+     *         | Type1
+     */
     def typ(): Tree = {
       val t =
         if (in.token == LPAREN) {
@@ -519,6 +520,11 @@ trait Parsers requires SyntaxAnalyzer {
           if (in.token == RPAREN) {
             in.nextToken();
             atPos(accept(ARROW)) { makeFunctionTypeTree(List(), typ()) }
+          } else if (in.token == ARROW) {
+            in.nextToken()
+            val t0 = typ()
+            accept(RPAREN)
+            atPos(accept(ARROW)) { makeByNameFunctionTypeTree(t0, typ()) }
           } else {
             val t0 = typ();
             if (in.token == COMMA) {
@@ -1533,8 +1539,9 @@ trait Parsers requires SyntaxAnalyzer {
     }
 
     /** FunDef ::= FunSig `:' Type `=' Expr
-     *           | this ParamClause ParamClauses `=' ConstrExpr
-     *  FunDcl ::= FunSig `:' Type
+                 | FunSig Block
+     *           | this ParamClause ParamClauses (`=' ConstrExpr | ConstrBlock)
+     *  FunDcl ::= FunSig [`:' Type]
      *  FunSig ::= id [FunTypeParamClause] ParamClauses
      */
     def funDefOrDcl(mods: Modifiers): Tree =
@@ -1542,42 +1549,34 @@ trait Parsers requires SyntaxAnalyzer {
         if (in.token == THIS) {
           in.nextToken();
           val vparamss = paramClauses(nme.CONSTRUCTOR, List(), false);
-          accept(EQUALS);
-          DefDef(mods, nme.CONSTRUCTOR, List(), vparamss, TypeTree(), constrExpr())
+          val rhs = if (in.token == LBRACE) constrBlock()
+                    else { accept(EQUALS); constrExpr() }
+          DefDef(mods, nme.CONSTRUCTOR, List(), vparamss, TypeTree(), rhs)
         } else {
           var newmods = mods;
           val name = ident();
           val implicitViews = new ListBuffer[Tree];
           val tparams = typeParamClauseOpt(name, implicitViews);
           val vparamss = paramClauses(name, implicitViews.toList, false);
-          val restype = typedOpt();
+          var restype = typedOpt();
           val rhs =
-            if (restype.isEmpty || in.token == EQUALS) equalsExpr();
-            else {
+            if (in.token == SEMI || in.token == NEWLINE || in.token == RBRACE) {
+              if (restype.isEmpty) restype = scalaUnitConstr
               newmods = newmods | Flags.DEFERRED;
               EmptyTree
-            }
+            } else if (restype.isEmpty && in.token == LBRACE) {
+              restype = scalaUnitConstr
+              block()
+            } else equalsExpr()
           DefDef(newmods, name, tparams, vparamss, restype, rhs)
         }
       }
 
     /** ConstrExpr      ::=  SelfInvocation
-     *                    |  `{' SelfInvocation {StatementSeparator BlockStat} `}'
-     *  SelfInvocation  ::= this ArgumentExprs {ArgumentExprs}
+     *                    |  ConstrBlock
      */
     def constrExpr(): Tree =
-      if (in.token == LBRACE) {
-        atPos(in.skipToken()) {
-          val statlist = new ListBuffer[Tree];
-          statlist += selfInvocation();
-          val stats =
-            if (in.token == SEMI || in.token == NEWLINE) {
-              in.nextToken(); blockStatSeq(statlist)
-            } else statlist.toList;
-          accept(RBRACE)
-          makeBlock(stats)
-        }
-      } else selfInvocation()
+      if (in.token == LBRACE) constrBlock() else selfInvocation()
 
     /** SelfInvocation  ::= this ArgumentExprs {ArgumentExprs}
      */
@@ -1588,6 +1587,20 @@ trait Parsers requires SyntaxAnalyzer {
         t
       }
 
+    /** ConstrBlock    ::=  `{' SelfInvocation {StatementSeparator BlockStat} `}'
+     */
+    def constrBlock(): Tree =
+      atPos(in.skipToken()) {
+        val statlist = new ListBuffer[Tree];
+        statlist += selfInvocation();
+        val stats =
+          if (in.token == SEMI || in.token == NEWLINE) {
+            in.nextToken(); blockStatSeq(statlist)
+          } else statlist.toList;
+        accept(RBRACE)
+        makeBlock(stats)
+      }
+
     /** TypeDef ::= Id [TypeParamClause] `=' Type
      *  TypeDcl ::= Id TypeBounds
      */
diff --git a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
index 2282802c24..329a65d5bb 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
@@ -23,6 +23,8 @@ abstract class TreeBuilder {
     Select(Ident(nme.scala_) setSymbol definitions.ScalaPackage, name)
   def scalaAnyRefConstr: Tree =
     scalaDot(nme.AnyRef.toTypeName)
+  def scalaUnitConstr: Tree =
+    scalaDot(nme.Unit.toTypeName)
   def scalaScalaObjectConstr: Tree =
     scalaDot(nme.ScalaObject.toTypeName)
   def caseClassConstr: Tree =
@@ -382,10 +384,14 @@ abstract class TreeBuilder {
       }
   }
 
-  /** Create a tree representing a function type */
+  /** Create a tree representing the function type (argtpes) => restpe */
   def makeFunctionTypeTree(argtpes: List[Tree], restpe: Tree): Tree =
     AppliedTypeTree(scalaDot(newTypeName("Function" + argtpes.length)), argtpes ::: List(restpe))
 
+  /** Create a tree representing a the name function type (=> argtpe) => restpe */
+  def makeByNameFunctionTypeTree(argtpe: Tree, restpe: Tree): Tree =
+    AppliedTypeTree(scalaDot(newTypeName("ByNameFunction")), List(argtpe, restpe))
+
   /** Append implicit view section if for `implicitViews' if nonempty */
   def addImplicitViews(owner: Name, vparamss: List[List[ValDef]], implicitViews: List[Tree]): List[List[ValDef]] = {
     val mods = Modifiers(if (owner.isTypeName) PARAMACCESSOR | LOCAL | PRIVATE else PARAM)
diff --git a/src/library/scala/ByNameFunction.scala b/src/library/scala/ByNameFunction.scala
index 0773c90863..bb423d5412 100755
--- a/src/library/scala/ByNameFunction.scala
+++ b/src/library/scala/ByNameFunction.scala
@@ -22,5 +22,6 @@ package scala;
  */
 trait ByNameFunction[-A, +B] extends AnyRef {
   def apply(x: => A): B
+  override def toString() = "<function>"
 }