*** empty log message ***

7 files changed, 53 insertions, 17 deletions

diff --git a/sources/scala/tools/nsc/Main.scala b/sources/scala/tools/nsc/Main.scala
index 7d5934db6b..b3b314a783 100755
--- a/sources/scala/tools/nsc/Main.scala
+++ b/sources/scala/tools/nsc/Main.scala
@@ -59,8 +59,7 @@ object Main {
 	else
 	  compiler.compile(command.files);
       } catch {
-	case ex: FatalError => // todo: replace with ex @ FatalError(msg)
-          val msg = ex.msg;
+	case ex @ FatalError(msg) =>
 	  if (command.settings.debug.value)
 	    ex.printStackTrace();
 	  reporter.error(null, "fatal error: " + msg);
diff --git a/sources/scala/tools/nsc/ast/TreeInfo.scala b/sources/scala/tools/nsc/ast/TreeInfo.scala
index d0bd3011ea..486dc14751 100644
--- a/sources/scala/tools/nsc/ast/TreeInfo.scala
+++ b/sources/scala/tools/nsc/ast/TreeInfo.scala
@@ -145,6 +145,27 @@ abstract class TreeInfo {
     case _ => false
   }
 
+  /** Is this pattern node a catch-all or type-test pattern? */
+  def isCatchCase(cdef: CaseDef) = cdef match {
+    case CaseDef(Typed(Ident(nme.WILDCARD), tpt), EmptyTree, _) => isSimple(tpt.tpe)
+    case CaseDef(Bind(_, Typed(Ident(nme.WILDCARD), tpt)), EmptyTree, _) => isSimple(tpt.tpe)
+    case _ => isDefaultCase(cdef)
+  }
+
+  private def isSimple(tp: Type): boolean = true;
+  /* If we have run-time types, and these are used for pattern matching,
+     we should replace this  by something like:
+
+      tp match {
+        case TypeRef(pre, sym, args) =>
+          args.isEmpty && (sym.owner.isPackageClass || isSimple(pre))
+        case NoPrefix =>
+          true
+        case _ =>
+          false
+      }
+*/
+
   /** Is this pattern node a sequence-valued pattern? */
   def isSequenceValued(tree: Tree): boolean = tree match {
     case Bind(_, body) => isSequenceValued(body)
diff --git a/sources/scala/tools/nsc/ast/Trees.scala b/sources/scala/tools/nsc/ast/Trees.scala
index cdfe4ce8b4..80c4b6edf5 100644
--- a/sources/scala/tools/nsc/ast/Trees.scala
+++ b/sources/scala/tools/nsc/ast/Trees.scala
@@ -285,6 +285,9 @@ abstract class Trees: Global {
   case class Bind(name: Name, body: Tree)
        extends DefTree;
 
+  def Bind(sym: Symbol, body: Tree): Bind =
+    Bind(sym.name, body) setSymbol sym;
+
   /** Array of expressions, needs to be translated in backend,
    */
   case class ArrayValue(elemtpt: Tree, elems: List[Tree])
diff --git a/sources/scala/tools/nsc/ast/parser/Tokens.scala b/sources/scala/tools/nsc/ast/parser/Tokens.scala
index 853e97e2e3..67c7572aac 100644
--- a/sources/scala/tools/nsc/ast/parser/Tokens.scala
+++ b/sources/scala/tools/nsc/ast/parser/Tokens.scala
@@ -80,7 +80,7 @@ object Tokens {
   final val SUPERTYPE = 71;
   final val HASH = 72;
   final val AT = 73;
-  final val VIEWBOUND = 74; //todo: elim
+  final val VIEWBOUND = 74; //todo: elim?
 
   /** parenthesis */
   final val LPAREN = 90;
diff --git a/sources/scala/tools/nsc/symtab/StdNames.scala b/sources/scala/tools/nsc/symtab/StdNames.scala
index 2942e11473..1bade64f38 100755
--- a/sources/scala/tools/nsc/symtab/StdNames.scala
+++ b/sources/scala/tools/nsc/symtab/StdNames.scala
@@ -126,7 +126,7 @@ abstract class StdNames: SymbolTable {
       newTermName(name.toString() + MODULE_SUFFIX);
 
     def isModuleVarName(name: Name): boolean =
-      name.endsWith(MODULE_SUFFIX); //todo handle also local modules
+      name.endsWith(MODULE_SUFFIX);
 
     def superName(name: Name) = newTermName("super$" + name);
 
diff --git a/sources/scala/tools/nsc/transform/UnCurry.scala b/sources/scala/tools/nsc/transform/UnCurry.scala
index 741e530a44..ba70ab3bbc 100755
--- a/sources/scala/tools/nsc/transform/UnCurry.scala
+++ b/sources/scala/tools/nsc/transform/UnCurry.scala
@@ -120,12 +120,6 @@ abstract class UnCurry extends InfoTransform {
 	val pat1 = transform(pat);
 	inPattern = false;
 	copy.CaseDef(tree, pat1, transform(guard), transform(body))
-/*
-      case Try(body, catches, finally) =>
-	catches1 = catches map {
-	  case cdef @ CaseDef(pat, guard, body) if TreeInfo.isDefaultCase(cdef) =>
-	    CaseDef(TypedTree(Ident(TreeInfo.defaultCaseVar(pat)), TypeTree(ThrowableClass.tpe)))
-*/
       case _ =>
         val tree1 = super.transform(tree);
 	if (isByNameRef(tree1))
@@ -147,6 +141,25 @@ abstract class UnCurry extends InfoTransform {
       tree match {
         case DefDef(mods, name, tparams, vparamss, tpt, rhs) =>
           copy.DefDef(tree, mods, name, tparams, List(List.flatten(vparamss)), tpt, rhs);
+        case Try(body, catches, finalizer) =>
+          if (catches forall treeInfo.isCatchCase) tree
+          else {
+            val exname = unit.fresh.newName("ex$");
+            val cases =
+              if (catches exists treeInfo.isDefaultCase) catches
+              else catches ::: List(CaseDef(Ident(nme.WILDCARD), EmptyTree, Throw(Ident(exname))));
+            val catchall =
+              atPos(tree.pos) {
+                CaseDef(
+                  Bind(exname, Ident(nme.WILDCARD)),
+                  EmptyTree,
+                  Match(Ident(exname), cases))
+              }
+            System.out.println("rewrote try: " + catches + " ==> " + catchall);
+            val catches1 = typer.atOwner(currentOwner).typedCases(
+              tree, List(catchall), ThrowableClass.tpe, WildcardType);
+            copy.Try(tree, body, catches1, finalizer)
+          }
 	case Apply(Apply(fn, args), args1) =>
 	  copy.Apply(tree, fn, args ::: args1)
 	case Ident(name) =>
diff --git a/sources/scala/tools/nsc/typechecker/Typers.scala b/sources/scala/tools/nsc/typechecker/Typers.scala
index 1b108537b7..ffef937b0a 100755
--- a/sources/scala/tools/nsc/typechecker/Typers.scala
+++ b/sources/scala/tools/nsc/typechecker/Typers.scala
@@ -682,6 +682,11 @@ abstract class Typers: Analyzer {
       copy.CaseDef(cdef, pat1, guard1, body1) setType body1.tpe
     }
 
+    def typedCases(tree: Tree, cases: List[CaseDef], pattp: Type, pt: Type): List[CaseDef] = {
+      List.mapConserve(cases)(cdef =>
+	newTyper(context.makeNewScope(tree, context.owner)).typedCase(cdef, pattp, pt))
+    }
+
     /*  Transform a function node (x_1,...,x_n) => body of type FunctionN[T_1, .., T_N, R] to
      *
      *    class $anon() extends Object() with FunctionN[T_1, .., T_N, R] with ScalaObject {
@@ -800,11 +805,6 @@ abstract class Typers: Analyzer {
 
       def ptOrLub(tps: List[Type]) = if (isFullyDefined(pt)) pt else lub(tps);
 
-      def typedCases(cases: List[CaseDef], pattp: Type): List[CaseDef] = {
-        List.mapConserve(cases)(cdef =>
-	  newTyper(context.makeNewScope(tree, context.owner)).typedCase(cdef, pattp, pt))
-      }
-
       def typedTypeApply(fun: Tree, args: List[Tree]): Tree = fun.tpe match {
 	case OverloadedType(pre, alts) =>
           inferPolyAlternatives(fun, args.length);
@@ -1155,7 +1155,7 @@ abstract class Typers: Analyzer {
 
         case Match(selector, cases) =>
           val selector1 = typed(selector);
-          val cases1 = typedCases(cases, selector1.tpe);
+          val cases1 = typedCases(tree, cases, selector1.tpe, pt);
           copy.Match(tree, selector1, cases1) setType ptOrLub(cases1 map (.tpe))
 
         case Return(expr) =>
@@ -1171,7 +1171,7 @@ abstract class Typers: Analyzer {
 
         case Try(block, catches, finalizer) =>
           val block1 = typed(block, pt);
-          val catches1 = typedCases(catches, ThrowableClass.tpe);
+          val catches1 = typedCases(tree, catches, ThrowableClass.tpe, pt);
           val finalizer1 = if (finalizer.isEmpty) finalizer
                            else typed(finalizer, UnitClass.tpe);
           copy.Try(tree, block1, catches1, finalizer1)