[dart2js] Report an error if throw is used outside of catch expression without an argument.

lib/compiler/implementation/resolver.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.
 
 abstract class TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(TypeAnnotation annotation);
   bool isParameterChecked(Element element);
 }
@@ skipping 1011 matching lines @@
     return arguments.toLink();
   }
 }
 
 class ResolverVisitor extends CommonResolverVisitor<Element> {
   final TreeElementMapping mapping;
   final Element enclosingElement;
   final TypeResolver typeResolver;
   bool inInstanceContext;
   bool inCheckContext;
+  bool inCatchBlock;
   Scope scope;
   ClassElement currentClass;
   ExpressionStatement currentExpressionStatement;
   bool typeRequired = false;
   StatementScope statementScope;
   int allowedCategory = ElementCategory.VARIABLE | ElementCategory.FUNCTION;
 
   ResolverVisitor(Compiler compiler, Element element)
     : this.mapping  = new TreeElementMapping(element),
       this.enclosingElement = element,
       // When the element is a field, we are actually resolving its
       // initial value, which should not have access to instance
       // fields.
       inInstanceContext = (element.isInstanceMember() && !element.isField())
           || element.isGenerativeConstructor(),
       this.currentClass = element.isMember() ? element.getEnclosingClass()
                                              : null,
       this.statementScope = new StatementScope(),
       typeResolver = new TypeResolver(compiler),
       scope = element.buildScope(),
       inCheckContext = compiler.enableTypeAssertions,
+      inCatchBlock = false,
       super(compiler);
 
   Enqueuer get world => compiler.enqueuer.resolution;
 
   Element lookup(Node node, SourceString name) {
     Element result = scope.lookup(name);
     if (!inInstanceContext && result != null && result.isInstanceMember()) {
       error(node, MessageKind.NO_INSTANCE_AVAILABLE, [node]);
     }
     return result;
@@ skipping 612 matching lines @@
 
   visitOperator(Operator node) {
     unimplemented(node, 'operator');
   }
 
   visitReturn(Return node) {
     visit(node.expression);
   }
 
   visitThrow(Throw node) {
+    if (!inCatchBlock && node.expression === null) {
+      error(node, MessageKind.THROW_WITHOUT_EXPRESSION);
+    }
     visit(node.expression);
   }
 
   visitVariableDefinitions(VariableDefinitions node) {
     visit(node.type);
     VariableDefinitionsVisitor visitor =
         new VariableDefinitionsVisitor(compiler, node, this,
                                        ElementKind.VARIABLE);
     visitor.visit(node.definitions);
   }
@@ skipping 409 matching lines @@
         }
       }
     }
 
     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;
   }
 
   visitTypedef(Typedef node) {
     unimplemented(node, 'typedef');
   }
 }
 
 class TypeDefinitionVisitor extends CommonResolverVisitor<DartType> {
   Scope scope;
   TypeDeclarationElement element;
@@ skipping 922 matching lines @@
     return result;
   }
   Element lookup(SourceString name) => localLookup(name);
   Element lexicalLookup(SourceString name) => localLookup(name);
 
   Element add(Element newElement) {
     throw "Cannot add an element in a patch library scope";
   }
   String toString() => 'PatchLibraryScope($origin,$patch)';
 }