Fix to give `LineInfo` to options error spans.

pkg/analyzer/lib/src/task/options.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 analyzer.src.task.options;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/plugin/options.dart';
 import 'package:analyzer/source/analysis_options_provider.dart';
 import 'package:analyzer/src/generated/engine.dart';
@@ skipping 30 matching lines @@
 /// A task that generates errors for an `.analysis_options` file.
 class GenerateOptionsErrorsTask extends SourceBasedAnalysisTask {
   /// The name of the input whose value is the content of the file.
   static const String CONTENT_INPUT_NAME = 'CONTENT_INPUT_NAME';
 
   /// The task descriptor describing this kind of task.
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'GenerateOptionsErrorsTask',
       createTask,
       buildInputs,
-      <ResultDescriptor>[ANALYSIS_OPTIONS_ERRORS]);
+      <ResultDescriptor>[ANALYSIS_OPTIONS_ERRORS, LINE_INFO]);
 
   final AnalysisOptionsProvider optionsProvider = new AnalysisOptionsProvider();
 
   GenerateOptionsErrorsTask(AnalysisContext context, AnalysisTarget target)
       : super(context, target);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   Source get source => target.source;
@@ skipping 12 matching lines @@
       SourceSpan span = e.span;
       var error = new AnalysisError(source, span.start.column + 1, span.length,
           AnalysisOptionsErrorCode.PARSE_ERROR, [e.message]);
       errors.add(error);
     }
 
     //
     // Record outputs.
     //
     outputs[ANALYSIS_OPTIONS_ERRORS] = errors;
+    outputs[LINE_INFO] = _computeLineInfo(content);
   }
 
   List<AnalysisError> _validate(Map<String, YamlNode> options) =>
       new OptionsFileValidator(source).validate(options);
 
   /// Return a map from the names of the inputs of this kind of task to the
   /// task input descriptors describing those inputs for a task with the
   /// given [target].
   static Map<String, TaskInput> buildInputs(Source source) =>
       <String, TaskInput>{CONTENT_INPUT_NAME: CONTENT.of(source)};
 
   /// Create a task based on the given [target] in the given [context].
   static GenerateOptionsErrorsTask createTask(
           AnalysisContext context, AnalysisTarget target) =>
       new GenerateOptionsErrorsTask(context, target);
+
+  /// Compute [LineInfo] for the given [content].
+  static LineInfo _computeLineInfo(String content) {
+    List<int> lineStarts = <int>[0];
+    for (int index = 0; index < content.length; index++) {
+      if (content.codeUnitAt(index) == 0x0A) {

[Brian Wilkerson, 2015/10/27 13:18:29]

For Dart files we accept either CR, CR/LF, or LF as an end of line marker. I
think we need to do the same thing here.

[pquitslund, 2015/10/27 15:31:44]

I was folllowing HTML's suit but this is not a bad idea.

I'm probably being thick but could you point me to where line info is computed
for Dart files?

[Brian Wilkerson, 2015/10/27 15:59:44]

We compute line info while scanning, as part of the Scanner.

+        lineStarts.add(index + 1);
+      }
+    }
+    return new LineInfo(lineStarts);
+  }
 }
 
 /// Validates `linter` top-level options.
 /// TODO(pq): move into `linter` package and plugin.
 class LinterOptionsValidator extends TopLevelOptionValidator {
   LinterOptionsValidator() : super('linter', const ['rules']);
 }
 
 /// Validates options defined in an `.analysis_options` file.
 class OptionsFileValidator {
@@ skipping 35 matching lines @@
                 AnalysisOptionsWarningCode.UNSUPPORTED_OPTION,
                 k.span,
                 [pluginName, k.value]);
           }
         }
         //TODO(pq): consider an error if the node is not a Scalar.
       });
     }
   }
 }