Type check try statements

sdk/lib/_internal/compiler/implementation/resolution/members.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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Set<Node> get superUses;
 
@@ skipping 2957 matching lines @@
       error(node, MessageKind.NO_CATCH_NOR_FINALLY);
     }
     visit(node.catchBlocks);
     visit(node.finallyBlock);
   }
 
   visitCatchBlock(CatchBlock node) {
     compiler.backend.registerCatchStatement(world, mapping);
     // Check that if catch part is present, then
     // it has one or two formal parameters.
+    VariableDefinitions exceptionDefinition;
+    VariableDefinitions stackTraceDefinition;
     if (node.formals != null) {
-      if (node.formals.isEmpty) {
+      Link<Node> link = node.formals.nodes;

[karlklose, 2013/05/27 12:43:54]

link -> formalsToProcess? formalsLink?

+      if (link.isEmpty) {
         error(node, MessageKind.EMPTY_CATCH_DECLARATION);
-      }
-      if (!node.formals.nodes.tail.isEmpty) {
-        if (!node.formals.nodes.tail.tail.isEmpty) {
-          for (Node extra in node.formals.nodes.tail.tail) {
-            error(extra, MessageKind.EXTRA_CATCH_DECLARATION);
+      } else {
+        exceptionDefinition = link.head;
+        link = link.tail;
+        if (!link.isEmpty) {
+          stackTraceDefinition = link.head;
+          link = link.tail;
+          if (!link.isEmpty) {
+            for (Node extra in link) {
+              error(extra, MessageKind.EXTRA_CATCH_DECLARATION);
+            }
           }
+          compiler.backend.registerStackTraceInCatch(mapping);
         }
-        compiler.backend.registerStackTraceInCatch(mapping);
       }
 
       // Check that the formals aren't optional and that they have no
       // modifiers or type.
-      for (Link<Node> link = node.formals.nodes;
-           !link.isEmpty;
-           link = link.tail) {
+      for (link = node.formals.nodes; !link.isEmpty; link = link.tail) {
         // If the formal parameter is a node list, it means that it is a
         // sequence of optional parameters.
         NodeList nodeList = link.head.asNodeList();
         if (nodeList != null) {
           error(nodeList, MessageKind.OPTIONAL_PARAMETER_IN_CATCH);
         } else {
           VariableDefinitions declaration = link.head;
           for (Node modifier in declaration.modifiers.nodes) {
             error(modifier, MessageKind.PARAMETER_WITH_MODIFIER_IN_CATCH);
           }
           TypeAnnotation type = declaration.type;
           if (type != null) {
             error(type, MessageKind.PARAMETER_WITH_TYPE_IN_CATCH);
           }
         }
       }
     }
 
     Scope blockScope = new BlockScope(scope);
     var wasTypeRequired = typeRequired;
     typeRequired = true;
     doInCheckContext(() => visitIn(node.type, blockScope));
     typeRequired = wasTypeRequired;
     visitIn(node.formals, blockScope);
     var oldInCatchBlock = inCatchBlock;
     inCatchBlock = true;
     visitIn(node.block, blockScope);
     inCatchBlock = oldInCatchBlock;
+
+    if (node.type != null && exceptionDefinition != null) {
+      DartType exceptionType = mapping.getType(node.type);
+      Node exceptionVariable = exceptionDefinition.definitions.nodes.head;
+      VariableElementX exceptionElement = mapping[exceptionVariable];
+      exceptionElement.variables.type = exceptionType;
+    }
+    if (stackTraceDefinition != null) {
+      Node stackTraceVariable = stackTraceDefinition.definitions.nodes.head;
+      VariableElementX stackTraceElement = mapping[stackTraceVariable];
+      world.registerInstantiatedClass(compiler.stackTraceClass, mapping);
+      stackTraceElement.variables.type = compiler.stackTraceClass.rawType;
+    }
   }
 
   visitTypedef(Typedef node) {
     unimplemented(node, 'typedef');
   }
 }
 
 class TypeDefinitionVisitor extends MappingVisitor<DartType> {
   Scope scope;
   final TypeDeclarationElement enclosingElement;
@@ skipping 905 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }