For reasons beyond logic, null matches any exception type.

dart/frog/leg/ssa/codegen.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.
 
 class SsaCodeGeneratorTask extends CompilerTask {
   SsaCodeGeneratorTask(Compiler compiler) : super(compiler);
   String get name() => 'SSA code generator';
 
   String generate(WorkItem work, HGraph graph) {
     return measure(() {
@@ skipping 911 matching lines @@
     use(input, JSPrecedence.MEMBER_PRECEDENCE);
     buffer.add('.constructor $cmp Array');
     endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
   }
 
   void visitIs(HIs node) {
     ClassElement element = node.typeExpression;
     LibraryElement coreLibrary = compiler.coreLibrary;
     ClassElement objectClass = coreLibrary.find(const SourceString('Object'));
     HInstruction input = node.expression;
+    if (node.nullOk) {
+      use(input, JSPrecedence.EQUALITY_PRECEDENCE);
+      buffer.add(' === (void 0) ||');
+      beginExpression(JSPrecedence.LOGICAL_OR_PRECEDENCE);

[Lasse Reichstein Nielsen, 2012/03/06 10:31:08]

Sadly, that won't do what you want. It doesn't change the expectations of the
following code, but merely puts a start parenthesis if the current expectation
is harder binding than a ||.

We can either create a function withPrecedence(precedence, thunk) that sets the
expected precedence during execution of  the thunk, or we can manually update
expectedPrecedence here (if it's the only place we need it, the extra
abstraction might be overdoing it).

I.e.:

int oldPrecedence = currentPrecedence;
if (node.nullOK) {
  ...
  currentPrecedence = LOGICAL_OR_PRECEDENCE;
}
... expression or RHS of || ...
if (node.nullOk) {
  currentPrecedence = oldPrecedence;
}

It breaks the abstraction a little, since we don't manipulate currentPrecedence
anywhere else outside of use/visit, but if it's only one place it should be
fine.

[ahe, 2012/03/06 10:57:38]

I think this is way too complicated, and I have no idea how to apply your
suggestion. The mental model behind this is apparently not based on building up
expressions from subexpressions. As long as that is not the case, this will be
an endless source of problems.

I think it was a mistake to add the precedence in this form. We would be better
off wrapping everything in parentheses.

I'll add a pair of parentheses.

+    }
     if (element == objectClass) {
       // TODO(ahe): This probably belongs in the constant folder.
       buffer.add('true');
     } else if (element == coreLibrary.find(const SourceString('String'))) {
       checkString(input, '===');
     } else if (element == coreLibrary.find(const SourceString('double'))) {
       checkDouble(input, '===');
     } else if (element == coreLibrary.find(const SourceString('num'))) {
       checkNum(input, '===');
     } else if (element == coreLibrary.find(const SourceString('bool'))) {
@@ skipping 45 matching lines @@
         buffer.add(compiler.emitter.nativeEmitter.dynamicIsCheckName);
         buffer.add('(');
         use(input, JSPrecedence.MEMBER_PRECEDENCE);
         buffer.add(", '${compiler.namer.operatorIs(node.typeExpression)}')");
         endExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
       }
       endExpression(precedence);
       if (endParen) buffer.add(')');
       endExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
     }
+    if (node.nullOk) {
+      endExpression(JSPrecedence.LOGICAL_OR_PRECEDENCE);
+    }
   }
 
   bool isStringSupertype(ClassElement cls) {
     LibraryElement coreLibrary = compiler.coreLibrary;
     return (cls == coreLibrary.find(const SourceString('Comparable')))
       || (cls == coreLibrary.find(const SourceString('Hashable')))
       || (cls == coreLibrary.find(const SourceString('Pattern')));
   }
 
   bool isListOrSupertype(ClassElement cls) {
@@ skipping 368 matching lines @@
       startBailoutSwitch();
     }
   }
 
   void endElse(HIf node) {
     if (node.elseBlock.hasBailouts()) {
       endBailoutSwitch();
     }
   }
 }