Implement generalized function types.

pkg/compiler/lib/src/tree/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 'dart:collection' show IterableMixin;
 
 import 'package:front_end/src/fasta/fasta_codes.dart' show FastaMessage;
 import 'package:front_end/src/fasta/scanner.dart' show BeginGroupToken, Token;
 import 'package:front_end/src/fasta/scanner/token_constants.dart' as Tokens
     show PLUS_TOKEN;
@@ skipping 1959 matching lines @@
   /** Bit pattern to easy check what modifiers are present. */
   final int flags;
 
   static const int FLAG_STATIC = 1;
   static const int FLAG_ABSTRACT = FLAG_STATIC << 1;
   static const int FLAG_FINAL = FLAG_ABSTRACT << 1;
   static const int FLAG_VAR = FLAG_FINAL << 1;
   static const int FLAG_CONST = FLAG_VAR << 1;
   static const int FLAG_FACTORY = FLAG_CONST << 1;
   static const int FLAG_EXTERNAL = FLAG_FACTORY << 1;
+  static const int FLAG_COVARIANT = FLAG_EXTERNAL << 1;
 
   Modifiers(NodeList nodes) : this.withFlags(nodes, computeFlags(nodes.nodes));
 
   Modifiers.withFlags(this.nodes, this.flags);
 
   static int computeFlags(Link<Node> nodes) {
     int flags = 0;
     for (; !nodes.isEmpty; nodes = nodes.tail) {
       String value = nodes.head.asIdentifier().source;
       if (identical(value, 'static'))
         flags |= FLAG_STATIC;
       else if (identical(value, 'abstract'))
         flags |= FLAG_ABSTRACT;
       else if (identical(value, 'final'))
         flags |= FLAG_FINAL;
       else if (identical(value, 'var'))
         flags |= FLAG_VAR;
       else if (identical(value, 'const'))
         flags |= FLAG_CONST;
       else if (identical(value, 'factory'))
         flags |= FLAG_FACTORY;
       else if (identical(value, 'external'))
         flags |= FLAG_EXTERNAL;
+      else if (identical(value, 'covariant'))
+        flags |= FLAG_COVARIANT;
       else
         throw 'internal error: ${nodes.head}';
     }
     return flags;
   }
 
   Node findModifier(String modifier) {
     Link<Node> nodeList = nodes.nodes;
     for (; !nodeList.isEmpty; nodeList = nodeList.tail) {
       String value = nodeList.head.asIdentifier().source;
@@ skipping 16 matching lines @@
 
   visitChildren1(Visitor1 visitor, arg) => nodes.accept1(visitor, arg);
 
   bool get isStatic => (flags & FLAG_STATIC) != 0;
   bool get isAbstract => (flags & FLAG_ABSTRACT) != 0;
   bool get isFinal => (flags & FLAG_FINAL) != 0;
   bool get isVar => (flags & FLAG_VAR) != 0;
   bool get isConst => (flags & FLAG_CONST) != 0;
   bool get isFactory => (flags & FLAG_FACTORY) != 0;
   bool get isExternal => (flags & FLAG_EXTERNAL) != 0;
+  bool get isCovariant => (flags & FLAG_COVARIANT) != 0;
 
   Node getStatic() => findModifier('static');
 
   /**
    * Use this to check if the declaration is either explicitly or implicitly
    * final.
    */
   bool get isFinalOrConst => isFinal || isConst;
 
   String toString() {
     return modifiersToString(
         isStatic: isStatic,
         isAbstract: isAbstract,
         isFinal: isFinal,
         isVar: isVar,
         isConst: isConst,
         isFactory: isFactory,
-        isExternal: isExternal);
+        isExternal: isExternal,
+        isCovariant: isCovariant);
   }
 }
 
 class StringInterpolation extends StringNode {
   final LiteralString string;
   final NodeList parts;
 
   StringInterpolation(this.string, this.parts);
 
   StringInterpolation asStringInterpolation() => this;
@@ skipping 1211 matching lines @@
  */
 Object getTreeElement(TreeElementMixin node) => node._element;
 
 /**
  * Do not call this method directly.  Instead, use an instance of
  * TreeElements.
  */
 void setTreeElement(TreeElementMixin node, Object value) {
   node._element = value;
 }