dart2js: Avoid inserting redundant HTypeKnown

pkg/compiler/lib/src/ssa/nodes.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 '../closure.dart';
 import '../common.dart';
 import '../common_elements.dart' show CommonElements;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
@@ skipping 1399 matching lines @@
       assert(
           identical(oldInstruction, _source),
           'Input ${index} of ${user} changed.'
           '\n  Found: ${oldInstruction}\n  Expected: ${_source}');
       user.inputs[index] = newInstruction;
       oldInstruction.usedBy.remove(user);
       newInstruction.usedBy.add(user);
     }
   }
 
+  bool get isSingleton => _instructions.length == 1;
+
+  HInstruction get single => _instructions.single;
+
   void _addUse(HInstruction user, int inputIndex) {
     _instructions.add(user);
     _indexes.add(inputIndex);
   }
 
   void _compute(HInstruction source, HInstruction dominator,
       bool excludeDominator, bool excludePhiOutEdges) {
     // Keep track of all instructions that we have to deal with later and count
     // the number of them that are in the current block.
     Set<HInstruction> users = new Setlet<HInstruction>();
@@ skipping 1609 matching lines @@
     return kind == other.kind &&
         typeExpression == other.typeExpression &&
         checkedType == other.checkedType &&
         receiverTypeCheckSelector == other.receiverTypeCheckSelector;
   }
 }
 
 /// The [HTypeKnown] instruction marks a value with a refined type.
 class HTypeKnown extends HCheck {
   TypeMask knownType;
-  bool _isMovable;
+  final bool _isMovable;
 
   HTypeKnown.pinned(TypeMask knownType, HInstruction input)
       : this.knownType = knownType,
         this._isMovable = false,
         super(<HInstruction>[input], knownType);
 
   HTypeKnown.witnessed(
       TypeMask knownType, HInstruction input, HInstruction witness)
       : this.knownType = knownType,
         this._isMovable = true,
         super(<HInstruction>[input, witness], knownType);
 
   toString() => 'TypeKnown $knownType';
   accept(HVisitor visitor) => visitor.visitTypeKnown(this);
 
   bool isJsStatement() => false;
   bool isControlFlow() => false;
   bool canThrow() => false;
 
+  bool get isPinned => inputs.length == 1;
+
   HInstruction get witness => inputs.length == 2 ? inputs[1] : null;
 
   int typeCode() => HInstruction.TYPE_KNOWN_TYPECODE;
   bool typeEquals(HInstruction other) => other is HTypeKnown;
   bool isCodeMotionInvariant() => true;
   bool get isMovable => _isMovable && useGvn();
 
   bool dataEquals(HTypeKnown other) {
     return knownType == other.knownType &&
         instructionType == other.instructionType;
@@ skipping 443 matching lines @@
   // ignore: MISSING_RETURN
   String get kindAsString {
     switch (kind) {
       case TypeInfoExpressionKind.COMPLETE:
         return 'COMPLETE';
       case TypeInfoExpressionKind.INSTANCE:
         return 'INSTANCE';
     }
   }
 }