anchor.diff:    }
   
     SimpleIdentifier _buildSimpleIdentifier(kernel.Reference reference) {
  -    if (reference == null) {
  -      throw const _CompilationErrorFound();
  -    }
       String name = reference.canonicalName.name;
       SimpleIdentifier identifier = AstTestFactory.identifier3(name);
       Element element = _getElement(reference);
  
positive.code:       }
  
        return AstTestFactory.mapLiteral(keyword, typeArguments, entries);
      }
  
      // Invalid initializers and  annotations are represented as Let.
      if (expr is kernel.Let) {
        var body = expr.body;
        if (_isStaticError(body)) {
          throw const _CompilationErrorFound();
        }
        if (body is kernel.Let) {
          var initializer = body.variable.initializer;
          if (initializer is kernel.Let && _isStaticError(initializer.body)) {
            throw const _CompilationErrorFound();
          }
        }
      }
  
      // Stop if there is an error.
      if (_isStaticError(expr)) {
        throw const _CompilationErrorFound();
      }
  
      if (expr is kernel.StaticGet) {
  
negative.code:     throw new ArgumentError(name);
    }
  
    static bool _hasInvalidExpression(kernel.Expression expr) {
      var visitor = new _HasInvalidExpressionVisitor();
      expr.accept(visitor);
      return visitor.result;
    }
  }
  
  class _HasInvalidExpressionVisitor extends kernel.RecursiveVisitor<void> {
    bool result = false;
  
    @override
    void visitInvalidExpression(kernel.InvalidExpression node) {
      result = true;
    }
  }
  
  