Replace and remove JavaException(s).

pkg/analyzer/lib/src/dart/resolver/scope.dart

 // Copyright (c) 2014, 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.
 
 library analyzer.src.dart.resolver.scope;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/source.dart';
 
 /**
  * The scope defined by a block.
  */
 class BlockScope extends EnclosedScope {
   /**
    * Initialize a newly created scope, enclosed within the [enclosingScope],
    * based on the given [classElement].
    */
   BlockScope(Scope enclosingScope, Block block) : super(enclosingScope) {
     if (block == null) {
-      throw new IllegalArgumentException("block cannot be null");
+      throw new ArgumentError("block cannot be null");
     }
     _defineElements(block);
   }
 
   void _defineElements(Block block) {
     for (Element element in elementsInBlock(block)) {
       define(element);
     }
   }
 
@@ skipping 23 matching lines @@
  * The scope defined by a class.
  */
 class ClassScope extends EnclosedScope {
   /**
    * Initialize a newly created scope, enclosed within the [enclosingScope],
    * based on the given [classElement].
    */
   ClassScope(Scope enclosingScope, ClassElement classElement)
       : super(enclosingScope) {
     if (classElement == null) {
-      throw new IllegalArgumentException("class element cannot be null");
+      throw new ArgumentError("class element cannot be null");
     }
     _defineMembers(classElement);
   }
 
   @override
   AnalysisError getErrorForDuplicate(Element existing, Element duplicate) {
     if (existing is PropertyAccessorElement && duplicate is MethodElement) {
       if (existing.nameOffset < duplicate.nameOffset) {
         return new AnalysisError(
             duplicate.source,
@@ skipping 83 matching lines @@
    */
   bool _parametersDefined = false;
 
   /**
    * Initialize a newly created scope, enclosed within the [enclosingScope],
    * that represents the given [_functionElement].
    */
   FunctionScope(Scope enclosingScope, this._functionElement)
       : super(new EnclosedScope(new EnclosedScope(enclosingScope))) {
     if (_functionElement == null) {
-      throw new IllegalArgumentException("function element cannot be null");
+      throw new ArgumentError("function element cannot be null");
     }
     _defineTypeParameters();
   }
 
   /**
    * Define the parameters for the given function in the scope that encloses
    * this function.
    */
   void defineParameters() {
     if (_parametersDefined) {
@@ skipping 960 matching lines @@
  * The scope defined by the type parameters in a class.
  */
 class TypeParameterScope extends EnclosedScope {
   /**
    * Initialize a newly created scope, enclosed within the [enclosingScope],
    * that defined the type parameters from the given [classElement].
    */
   TypeParameterScope(Scope enclosingScope, ClassElement classElement)
       : super(enclosingScope) {
     if (classElement == null) {
-      throw new IllegalArgumentException("class element cannot be null");
+      throw new ArgumentError("class element cannot be null");
     }
     _defineTypeParameters(classElement);
   }
 
   /**
    * Define the type parameters declared by the [classElement].
    */
   void _defineTypeParameters(ClassElement classElement) {
     for (TypeParameterElement typeParameter in classElement.typeParameters) {
       define(typeParameter);
     }
   }
 }