Add a friendly error message for using a tab as indentation.

utils/pub/yaml/parser.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.
 
 /**
  * Translates a string of characters into a YAML serialization tree.
  *
  * This parser is designed to closely follow the spec. All productions in the
  * spec are numbered, and the corresponding methods in the parser have the same
  * numbers. This is certainly not the most efficient way of parsing YAML, but it
@@ skipping 126 matching lines @@
    */
   int farthestLine = 0;
 
   /**
    * The column number of the farthest position that has been parsed
    * successfully before backtracking. Used for error reporting.
    */
   int farthestColumn = 0;
 
   /**
+   * The farthest position in the source string that has been parsed
+   * successfully before backtracking. Used for error reporting.
+   */
+  int farthestPos = 0;
+
+  /**
    * The name of the context of the farthest position that has been parsed
    * successfully before backtracking. Used for error reporting.
    */
   String farthestContext = "document";
 
   /** A stack of the names of parse contexts. Used for error reporting. */
   List<String> contextStack;
 
   /**
+   * Annotations attached to ranges of the source string that add extra
+   * information to any errors that occur in the annotated range.
+   */
+  _RangeMap<String> errorAnnotations;
+
+  /**
    * The buffer containing the string currently being captured.
    */
   StringBuffer capturedString;
 
   /**
    * The beginning of the current section of the captured string.
    */
   int captureStart;
 
   /**
    * Whether the current string capture is being overridden.
    */
   bool capturingAs = false;
 
   _Parser(String s)
     : this.s = s,
       len = s.length,
-      contextStack = <String>["document"];
+      contextStack = <String>["document"],
+      errorAnnotations = new _RangeMap();
 
   /**
    * Return the character at the current position, then move that position
    * forward one character. Also updates the current line and column numbers.
    */
   int next() {
     if (pos == len) return -1;
     var char = s.charCodeAt(pos++);
     if (isBreak(char)) {
       line++;
       column = 0;
     } else {
       column++;
     }
 
     if (farthestLine < line) {
       farthestLine = line;
       farthestColumn = column;
       farthestContext = contextStack.last();
     } else if (farthestLine == line && farthestColumn < column) {
       farthestColumn = column;
       farthestContext = contextStack.last();
     }
+    farthestPos = pos;
 
     return char;
   }
 
   /**
    * Returns the character at the current position, or the character [i]
    * characters after the current position.
    *
    * Returns -1 if this would return a character after the end or before the
    * beginning of the input string.
@@ skipping 202 matching lines @@
   context(String name, fn()) {
     try {
       contextStack.add(name);
       return fn();
     } finally {
       var popped = contextStack.removeLast();
       assert(popped == name);
     }
   }
 
+  /**
+   * Adds [message] as extra information to any errors that occur between the
+   * current position and the position of the cursor after running [fn]. The
+   * cursor is reset after [fn] is run.
+   */
+  annotateError(String message, fn()) {
+    var start = pos;
+    var end;
+    transaction(() {
+      fn();
+      end = pos;
+      return false;
+    });
+    errorAnnotations[new _Range(start, end)] = message;
+  }
+
   /** Throws an error with additional context information. */
   error(String message) {
     // Line and column should be one-based.
     throw new SyntaxError(line + 1, column + 1,
         "$message (in $farthestContext)");
   }
 
   /**
    * If [result] is falsey, throws an error saying that [expected] was
    * expected.
    */
   expect(result, String expected) {
     if (truth(result)) return result;
     error("expected $expected");
   }
 
   /**
    * Throws an error saying that the parse failed. Uses [farthestLine],
    * [farthestColumn], and [farthestContext] to provide additional information.
    */
   parseFailed() {
-    throw new SyntaxError(farthestLine + 1, farthestColumn + 1,
-        "invalid YAML in $farthestContext");
+    var message = "invalid YAML in $farthestContext";
+    var extraError = errorAnnotations[farthestPos];
+    if (extraError != null) message = "$message ($extraError)";
+    throw new SyntaxError(farthestLine + 1, farthestColumn + 1, message);
   }
 
   /** Returns the number of spaces after the current position. */
   int countIndentation() {
     var i = 0;
     while (peek(i) == SP) i++;
     return i;
   }
 
   /** Returns the indentation for a block scalar. */
@@ skipping 215 matching lines @@
         ns_escNull, ns_escBell, ns_escBackspace, ns_escHorizontalTab,
         ns_escLineFeed, ns_escVerticalTab, ns_escFormFeed, ns_escCarriageReturn,
         ns_escEscape, ns_escSpace, ns_escDoubleQuote, ns_escSlash,
         ns_escBackslash, ns_escNextLine, ns_escNonBreakingSpace,
         ns_escLineSeparator, ns_escParagraphSeparator, ns_esc8Bit, ns_esc16Bit,
         ns_esc32Bit
       ]));
     }));
 
   // 63
-  bool s_indent(int indent) => nAtOnce(indent, (c, i) => c == SP);
+  bool s_indent(int indent) {
+    var result = nAtOnce(indent, (c, i) => c == SP);
+    if (peek() == TAB) {
+      annotateError("\\t is not allowed as indentation in YAML",

[Bob Nystrom, 2012/08/30 16:43:51]

I would use "tab characters" instead of the escape sequence here.

[nweiz, 2012/08/30 19:19:02]

Done.

+          () => zeroOrMore(() => consume(isSpace)));
+    }
+    return result;
+  }
 
   // 64
   bool s_indentLessThan(int indent) {
     for (int i = 0; i < indent - 1; i++) {
-      if (!consumeChar(SP)) break;
+      if (!consumeChar(SP)) {
+        if (peek() == TAB) {
+          annotateError("\\t is not allowed as indentation in YAML", () {

[Bob Nystrom, 2012/08/30 16:43:51]

Ditto.

[nweiz, 2012/08/30 19:19:02]

Done.

+            for (; i < indent - 1; i++) {
+              if (!consume(isSpace)) break;
+            }
+          });
+        }
+        break;
+      }
     }
     return true;
   }
 
   // 65
   bool s_indentLessThanOrEqualTo(int indent) => s_indentLessThan(indent + 1);
 
   // 66
   bool s_separateInLine() => transaction(() {
     return captureAs('', () =>
@@ skipping 1201 matching lines @@
 
 /** The information in the header for a block scalar. */
 class _BlockHeader {
   final int additionalIndent;
   final int chomping;
 
   _BlockHeader(this.additionalIndent, this.chomping);
 
   bool get autoDetectIndent => additionalIndent == null;
 }
+
+/**
+ * A range of characters in the YAML document, from [start] to [end] (inclusive).
+ */
+class _Range {
+  /** The first character in the range. */
+  final int start;
+
+  /** The last character in the range. */
+  final int end;
+
+  _Range(this.start, this.end);
+
+  /** Returns whether or not [pos] lies within this range. */
+  bool contains(int pos) => pos >= start && pos <= end;
+}
+
+/**
+ * A map that associates [E] values with [_Range]s. It's efficient to create new
+ * associations, but finding the value associated with a position is more
+ * expensive.
+ */
+class _RangeMap<E> {
+  /** The ranges and their associated elements. */
+  final List<_Pair<_Range, E>> contents;
+
+  _RangeMap() : this.contents = <_Pair<_Range, E>>[];
+
+  /**
+   * Returns the value associated with the range in which [pos] lies, or null if
+   * there is no such range. If there's more than one such range, the most
+   * recently set one is used.
+   */
+  E operator[](int pos) {
+    // Iterate backwards through contents so the more recent range takes
+    // precedence. TODO(nweiz): clean this up when issue 2804 is fixed.
+    for (var i = contents.length - 1; i >= 0; i--) {
+      var pair = contents[i];
+      if (pair.first.contains(pos)) return pair.last;
+    }
+    return null;
+  }
+
+  /** Associates [value] with [range]. */
+  operator[]=(_Range range, E value) =>
+    contents.add(new _Pair<_Range, E>(range, value));
+}