a === b -> identical(a, b)

tests/compiler/dart2js/resolver_test.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.
 
 import 'dart:uri';
 
 import "../../../sdk/lib/_internal/compiler/implementation/dart2jslib.dart"
        hide TreeElementMapping, TreeElements, SourceString;
 import "../../../sdk/lib/_internal/compiler/implementation/resolution/resolution.dart";
 import "../../../sdk/lib/_internal/compiler/implementation/elements/elements.dart";
@@ skipping 139 matching lines @@
   FunctionElement fooA = classA.lookupLocalMember(buildSourceString("foo"));
 
   ResolverVisitor visitor =
       new ResolverVisitor(compiler, fooB, new CollectingTreeElements(fooB));
   FunctionExpression node = fooB.parseNode(compiler);
   visitor.visit(node.body);
   Map mapping = map(visitor);
 
   Send superCall = node.body.asReturn().expression;
   FunctionElement called = mapping[superCall];
-  Expect.isTrue(called !== null);
+  Expect.isNotNull(called);
   Expect.equals(fooA, called);
 }
 
 testThis() {
   MockCompiler compiler = new MockCompiler();
   compiler.parseScript("class Foo { foo() { return this; } }");
   compiler.resolveStatement("Foo foo;");
   ClassElement fooElement = compiler.mainApp.find(buildSourceString("Foo"));
   FunctionElement funElement =
       fooElement.lookupLocalMember(buildSourceString("foo"));
@@ skipping 343 matching lines @@
   Expect.equals(ElementKind.FUNCTION, element.kind);
   Expect.equals(buildSourceString('f'), element.name);
   Expect.equals(element.parseNode(compiler), node);
 }
 
 testNewExpression() {
   MockCompiler compiler = new MockCompiler();
   compiler.parseScript("class A {} foo() { print(new A()); }");
   ClassElement aElement = compiler.mainApp.find(buildSourceString('A'));
   FunctionElement fooElement = compiler.mainApp.find(buildSourceString('foo'));
-  Expect.isTrue(aElement !== null);
-  Expect.isTrue(fooElement !== null);
+  Expect.isNotNull(aElement);
+  Expect.isNotNull(fooElement);
 
   fooElement.parseNode(compiler);
   compiler.resolver.resolve(fooElement);
 
   TreeElements elements = compiler.resolveStatement("new A();");
   NewExpression expression =
       compiler.parsedTree.asExpressionStatement().expression;
   Element element = elements[expression.send];
   Expect.equals(ElementKind.GENERATIVE_CONSTRUCTOR, element.kind);
   Expect.isTrue(element is SynthesizedConstructorElement);
@@ skipping 26 matching lines @@
                    String constructor, int expectedElementCount,
                    {List expectedWarnings: const [],
                     List expectedErrors: const [],
                     String corelib: DEFAULT_CORELIB}) {
   MockCompiler compiler = new MockCompiler(coreSource: corelib);
   compiler.parseScript(script);
   compiler.resolveStatement(statement);
   ClassElement classElement =
       compiler.mainApp.find(buildSourceString(className));
   Element element;
-  if (constructor !== '') {
+  if (constructor != '') {
     element = classElement.lookupConstructor(
         new Selector.callConstructor(buildSourceString(constructor),
                                      classElement.getLibrary()));
   } else {
     element = classElement.lookupConstructor(
         new Selector.callDefaultConstructor(classElement.getLibrary()));
   }
 
   FunctionExpression tree = element.parseNode(compiler);
   ResolverVisitor visitor =
@@ skipping 224 matching lines @@
         var d = new D();
         --d;
       }""";
   final compiler = compileScript(script);
 
   checkMemberResolved(compiler, 'A', operatorName('+', false));
   checkMemberResolved(compiler, 'B', operatorName('+', false));
   checkMemberResolved(compiler, 'C', operatorName('-', false));
   checkMemberResolved(compiler, 'D', operatorName('-', false));
 }