anchor.diff:    }
   
     visitLiteralMap(LiteralMap node) {
  -    fail(node);
  +    return unhandledExpression();
     }
   
     visitLiteralMapEntry(LiteralMapEntry node) {
  -    fail(node);
  +    return unhandledExpression();
     }
   
     visitNamedArgument(NamedArgument node) {
  -    fail(node, 'named argument not implemented');
  +    return unhandledExpression();
     }
   
     visitSwitchStatement(SwitchStatement node) {
  -    fail(node);
  +    return unhandledStatement();
     }
   
     visitSwitchCase(SwitchCase node) {
  -    fail(node);
  +    return unhandledStatement();
     }
   
     visitCaseMatch(CaseMatch node) {
  -    fail(node);
  +    return unhandledStatement();
     }
   
     visitTryStatement(TryStatement node) {
  -    fail(node, 'unimplemented');
  +    return unhandledStatement();
     }
   
     visitScriptTag(ScriptTag node) {
  -    fail(node);
  +    return unhandledExpression();
     }
   
     visitCatchBlock(CatchBlock node) {
  -    fail(node);
  +    return unhandledStatement();
     }
   
     visitTypedef(Typedef node) {
  -    fail(node);
  -  }
  -}
  +    return unhandledStatement();
  +  }
  +}
  
positive.code:   }
  
    Type visitLoop(Loop node) {
      fail(node, 'internal error');
    }
  
    Type lookupMethodType(Node node, ClassElement classElement,
  
negative.code:           if (receiverType === null) {
              fail(node.receiver, 'receivertype is null');
            }
            if (receiverType.element.kind === ElementKind.GETTER) {
              FunctionType getterType  = receiverType;
              receiverType = getterType.returnType;
            }
            ElementKind receiverKind = receiverType.element.kind;
            if (receiverKind === ElementKind.TYPEDEF) {
              // TODO(karlklose): handle typedefs.
              return null;
            }
            if (receiverKind === ElementKind.TYPE_VARIABLE) {
              // TODO(karlklose): handle type variables.
              return null;
            }
            if (receiverKind !== ElementKind.CLASS) {
              fail(node.receiver, 'unexpected receiver kind: ${receiverKind}');
            }
            ClassElement classElement = receiverType.element;
            // TODO(karlklose): substitute type arguments.
  