Add Timeout.none.

lib/src/runner/parse_metadata.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 test.runner.parse_metadata;
 
 import 'dart:io';
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 85 matching lines @@
     return _contextualize(literal,
         () => new PlatformSelector.parse(literal.stringValue));
   }
 
   /// Parses a `@Timeout` annotation.
   ///
   /// [annotation] is the annotation. [constructorName] is the name of the named
   /// constructor for the annotation, if any.
   Timeout _parseTimeout(Annotation annotation, String constructorName) {
     _assertConstructorName(constructorName, 'Timeout', annotation,
-        validNames: [null, 'factor']);
+        validNames: [null, 'factor', 'none']);
 
     var description = 'Timeout';
     if (constructorName != null) description += '.$constructorName'; 
 
+    if (constructorName == 'none') {
+      _assertNoArguments(annotation, description);
+      return Timeout.none;
+    }
+
     _assertArguments(annotation.arguments, description, annotation,
         positional: 1);
 
     var args = annotation.arguments.arguments;
     if (constructorName == null) return new Timeout(_parseDuration(args.first));
     return new Timeout.factor(_parseNum(args.first));
   }
 
   /// Parses a `Timeout` constructor.
   Timeout _parseTimeoutConstructor(InstanceCreationExpression constructor) {
@@ skipping 48 matching lines @@
         positional: 1);
 
     return _parseMap(annotation.arguments.arguments.first, key: (key) {
       var selector = _parseString(key);
       return _contextualize(selector,
           () => new PlatformSelector.parse(selector.stringValue));
     }, value: (value) {
       var expressions = [];
       if (value is ListLiteral) {
         expressions = _parseList(value);
-      } else if (value is InstanceCreationExpression) {
+      } else if (value is InstanceCreationExpression ||
+                 value is PrefixedIdentifier) {
         expressions = [value];
       } else {
         throw new SourceSpanFormatException(
             'Expected a Timeout, Skip, or List of those.',
             _spanFor(value));
       }
 
       var timeout;
       var skip;
       for (var expression in expressions) {
-        var className = expression is InstanceCreationExpression
-            ? _resolveConstructor(
-                expression.constructorName.type.name,
-                expression.constructorName.name).first
-            : null;
+        if (expression is InstanceCreationExpression) {
+          var className = _resolveConstructor(
+              expression.constructorName.type.name,
+              expression.constructorName.name).first;
 
-        if (className == 'Timeout') {
+          if (className == 'Timeout') {
+            _assertSingle(timeout, 'Timeout', expression);
+            timeout = _parseTimeoutConstructor(expression);
+            continue;
+          } else if (className == 'Skip') {
+            _assertSingle(skip, 'Skip', expression);
+            skip = _parseSkipConstructor(expression);
+            continue;
+          }
+        } else if (expression is PrefixedIdentifier &&
+            expression.prefix.name == 'Timeout') {
+          if (expression.identifier.name != 'none') {
+            throw new SourceSpanFormatException(
+                'Undefined value.', _spanFor(expression));
+          }
+
           _assertSingle(timeout, 'Timeout', expression);
-          timeout = _parseTimeoutConstructor(expression);
-        } else if (className == 'Skip') {
-          _assertSingle(skip, 'Skip', expression);
-          skip = _parseSkipConstructor(expression);
-        } else {
-          throw new SourceSpanFormatException(
-              'Expected a Timeout or Skip.',
-              _spanFor(expression));
+          timeout = Timeout.none;
+          continue;
         }
+
+        throw new SourceSpanFormatException(
+            'Expected a Timeout or Skip.',
+            _spanFor(expression));
       }
 
       return new Metadata.parse(timeout: timeout, skip: skip);
     });
   }
 
   /// Parses a `const Duration` expression.
   Duration _parseDuration(Expression expression) {
     _parseConstructor(expression, 'Duration');
 
@@ skipping 183 matching lines @@
       buffer.write("${positional + optional} argument");
       if (positional > 1) buffer.write("s");
       buffer.write(".");
       throw new SourceSpanFormatException(
           buffer.toString(), _spanFor(arguments));
     }
 
     return namedValues;
   }
 
+  /// Assert that [annotation] (described by [name]) has no argument list.
+  void _assertNoArguments(Annotation annotation, String name) {
+    if (annotation.arguments == null) return;
+    throw new SourceSpanFormatException(
+        "$name doesn't take arguments.", _spanFor(annotation));
+  }
+
   /// Parses a Map literal.
   ///
   /// By default, returns [Expression] keys and values. These can be overridden
   /// with the [key] and [value] parameters.
   Map _parseMap(Expression expression, {key(Expression expression),
       value(Expression expression)}) {
     if (key == null) key = (expression) => expression;
     if (value == null) value = (expression) => expression;
 
     if (expression is! MapLiteral) {
@@ skipping 66 matching lines @@
       return fn();
     } on SourceSpanFormatException catch (error) {
       var file = new SourceFile(new File(_path).readAsStringSync(),
           url: p.toUri(_path));
       var span = contextualizeSpan(error.span, literal, file);
       if (span == null) rethrow;
       throw new SourceSpanFormatException(error.message, span);
     }
   }
 }