Add Vector type to Kernel

pkg/kernel/lib/type_algebra.dart

 // Copyright (c) 2016, 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 kernel.type_algebra;
 
 import 'ast.dart';
 
 /// Returns a type where all occurrences of the given type parameters have been
 /// replaced with the corresponding types.
 ///
@@ skipping 347 matching lines @@
     if (useCounter == before) return node;
     return new NamedType(node.name, type);
   }
 
   DartType visit(DartType node) => node.accept(this);
 
   DartType visitInvalidType(InvalidType node) => node;
   DartType visitDynamicType(DynamicType node) => node;
   DartType visitVoidType(VoidType node) => node;
   DartType visitBottomType(BottomType node) => node;
+  DartType visitVector(VectorType node) => node;
 
   DartType visitInterfaceType(InterfaceType node) {
     if (node.typeArguments.isEmpty) return node;
     int before = useCounter;
     var typeArguments = node.typeArguments.map(visit).toList();
     if (useCounter == before) return node;
     return new InterfaceType(node.classNode, typeArguments);
   }
 
   List<TypeParameter> freshTypeParameters(List<TypeParameter> parameters) {
@@ skipping 154 matching lines @@
   }
 
   bool _unify(DartType type1, DartType type2) {
     if (!success) return false;
     type1 = type1 is TypeParameterType ? _substituteHead(type1) : type1;
     type2 = type2 is TypeParameterType ? _substituteHead(type2) : type2;
     if (type1 is DynamicType && type2 is DynamicType) return true;
     if (type1 is VoidType && type2 is VoidType) return true;
     if (type1 is InvalidType && type2 is InvalidType) return true;
     if (type1 is BottomType && type2 is BottomType) return true;
+    if (type1 is VectorType && type2 is VectorType) return true;
     if (type1 is InterfaceType && type2 is InterfaceType) {
       if (type1.classNode != type2.classNode) return _fail();
       assert(type1.typeArguments.length == type2.typeArguments.length);
       for (int i = 0; i < type1.typeArguments.length; ++i) {
         if (!_unify(type1.typeArguments[i], type2.typeArguments[i])) {
           return false;
         }
       }
       return true;
     }
@@ skipping 88 matching lines @@
 
   bool visit(DartType node) => node.accept(this);
 
   bool visitNamedType(NamedType node) {
     return visit(node.type);
   }
 
   bool visitInvalidType(InvalidType node) => false;
   bool visitDynamicType(DynamicType node) => false;
   bool visitVoidType(VoidType node) => false;
+  bool visitVectorType(VectorType node) => false;
 
   bool visitInterfaceType(InterfaceType node) {
     return node.typeArguments.any(visit);
   }
 
   bool visitFunctionType(FunctionType node) {
     return node.typeParameters.any(handleTypeParameter) ||
         node.positionalParameters.any(visit) ||
         node.namedParameters.any(visitNamedType) ||
         visit(node.returnType);
   }
 
   bool visitTypeParameterType(TypeParameterType node) {
     return variables == null || variables.contains(node.parameter);
   }
 
   bool handleTypeParameter(TypeParameter node) {
     assert(!variables.contains(node));
     return node.bound.accept(this);
   }
 }