Dart SDK Spelling b, c, and d.

pkg/dev_compiler/lib/src/compiler/code_generator.dart

 // Copyright (c) 2015, 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:collection' show HashMap, HashSet;
 import 'dart:math' show min, max;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 3213 matching lines @@
     op = op.substring(0, op.length - 1); // remove trailing '='
     return _emitOpAssign(left, right, op, node.staticElement, context: node);
   }
 
   JS.MetaLet _emitOpAssign(
       Expression left, Expression right, String op, MethodElement element,
       {Expression context}) {
     if (op == '??') {
       // Desugar `l ??= r` as ((x) => x == null ? l = r : x)(l)
       // Note that if `x` contains subexpressions, we need to ensure those
-      // are also evaluated only once. This is similar to desguaring for
+      // are also evaluated only once. This is similar to desugaring for
       // postfix expressions like `i++`.
 
       // Handle the left hand side, to ensure each of its subexpressions are
       // evaluated only once.
       var vars = <JS.MetaLetVariable, JS.Expression>{};
       var x = _bindLeftHandSide(vars, left, context: left);
       // Capture the result of evaluating the left hand side in a temp.
       var t = _bindValue(vars, 't', x, context: x);
       return new JS.MetaLet(vars, [
         js.call('# == null ? # : #', [_visit(t), _emitSet(x, right), _visit(t)])
@@ skipping 1134 matching lines @@
       Expression node, JS.Expression uncoerced) {
     // Don't coerce if the parent will coerce.
     AstNode parent = _parentOperation(node);
     if (_nodeIsBitwiseOperation(parent)) return uncoerced;
 
     // Don't do a no-op coerce if the most significant bit is zero.
     if (_is31BitUnsigned(node)) return uncoerced;
 
     // If the consumer of the expression is '==' or '!=' with a constant that
     // fits in 31 bits, adding a coercion does not change the result of the
-    // comparision, e.g.  `a & ~b == 0`.
+    // comparison, e.g.  `a & ~b == 0`.
     if (parent is BinaryExpression) {
       var tokenType = parent.operator.type;
       Expression left = parent.leftOperand;
       Expression right = parent.rightOperand;
       if (tokenType == TokenType.EQ_EQ || tokenType == TokenType.BANG_EQ) {
         const int MAX = 0x7fffffff;
         if (_asIntInRange(right, 0, MAX) != null) return uncoerced;
         if (_asIntInRange(left, 0, MAX) != null) return uncoerced;
       } else if (tokenType == TokenType.GT_GT) {
         if (_isDefinitelyNonNegative(left) &&
@@ skipping 1728 matching lines @@
   if (targetIdentifier.staticElement is! PrefixElement) return false;
   var prefix = targetIdentifier.staticElement as PrefixElement;
 
   // The library the prefix is referring to must come from a deferred import.
   var containingLibrary = resolutionMap
       .elementDeclaredByCompilationUnit(target.root as CompilationUnit)
       .library;
   var imports = containingLibrary.getImportsWithPrefix(prefix);
   return imports.length == 1 && imports[0].isDeferred;
 }