Stoppp using trippple consonants

pkg/analyzer/lib/src/generated/type_system.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.
 
 library analyzer.src.generated.type_system;
 
 import 'dart:collection';
 import 'dart:math' as math;
 
 import 'package:analyzer/dart/ast/ast.dart' show AstNode;
@@ skipping 787 matching lines @@
 
   /**
    * This currently does not implement a very complete least upper bound
    * algorithm, but handles a couple of the very common cases that are
    * causing pain in real code.  The current algorithm is:
    * 1. If either of the types is a supertype of the other, return it.
    *    This is in fact the best result in this case.
    * 2. If the two types have the same class element, then take the
    *    pointwise least upper bound of the type arguments.  This is again
    *    the best result, except that the recursive calls may not return
-   *    the true least uppper bounds.  The result is guaranteed to be a
+   *    the true least upper bounds.  The result is guaranteed to be a
    *    well-formed type under the assumption that the input types were
    *    well-formed (and assuming that the recursive calls return
    *    well-formed types).
    * 3. Otherwise return the spec-defined least upper bound.  This will
    *    be an upper bound, might (or might not) be least, and might
    *    (or might not) be a well-formed type.
    *
    * TODO(leafp): Use matchTypes or something similar here to handle the
    *  case where one of the types is a superclass (but not supertype) of
    *  the other, e.g. LUB(Iterable<double>, List<int>) = Iterable<num>
@@ skipping 1549 matching lines @@
     if (type is InterfaceTypeImpl) {
       return type.typeArguments.any(isUnknown);
     }
     if (type is FunctionType) {
       return isUnknown(type.returnType) ||
           type.parameters.any((p) => isUnknown(p.type));
     }
     return false;
   }
 }