analyzer_exp fixes

pkg/analyzer_experimental/lib/src/services/formatter_impl.dart

 // Copyright (c) 2013, 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 formatter_impl;
 
 import 'dart:math';
 
 import 'package:analyzer_experimental/analyzer.dart';
 import 'package:analyzer_experimental/src/generated/parser.dart';
@@ skipping 22 matching lines @@
   final int tabSize;
   final bool tabsForIndent;
   final int pageWidth;
 }
 
 
 /// Thrown when an error occurs in formatting.
 class FormatterException implements Exception {
 
   /// A message describing the error.
-  final message;
+  final String message;

[pquitslund, 2013/08/08 21:20:23]

Hmmmm.  The type seems gratuitous here.  Or?

[kevmoo-old, 2013/08/08 21:23:34]

Nope. It's great for the analyzer and doc generation. Inline, dynamic is great,
but for public API, default to type info.

 
   /// Creates a new FormatterException with an optional error [message].
   const FormatterException([this.message = '']);
 
   FormatterException.forError(List<AnalysisError> errors) :
     // TODO(pquitslund): add descriptive message based on errors
     message = 'an analysis error occured during format';
 
   String toString() => 'FormatterException: $message';
 }
 
 /// Specifies the kind of code snippet to format.
 class CodeKind {
 
-  final index;
+  final int _index;
 
-  const CodeKind(this.index);
+  const CodeKind._(this._index);
 
   /// A compilation unit snippet.
-  static const COMPILATION_UNIT = const CodeKind(0);
+  static const COMPILATION_UNIT = const CodeKind._(0);
 
   /// A statement snippet.
-  static const STATEMENT = const CodeKind(1);
+  static const STATEMENT = const CodeKind._(1);
 
 }
 
 /// Dart source code formatter.
 abstract class CodeFormatter {
 
   factory CodeFormatter([FormatterOptions options = const FormatterOptions()])
                         => new CodeFormatterImpl(options);
 
   /// Format the specified portion (from [offset] with [length]) of the given
@@ skipping 34 matching lines @@
     switch (kind) {
       case CodeKind.COMPILATION_UNIT:
         return parser.parseCompilationUnit(start);
       case CodeKind.STATEMENT:
         return parser.parseStatement(start);
     }
 
     throw new FormatterException('Unsupported format kind: $kind');
   }
 
-  checkForErrors() {
+  void checkForErrors() {

[pquitslund, 2013/08/08 21:20:23]

What's your thinking on when to specify a void return type?  I'm still feeling
it out but I sort of prefer to leave it off where it isn't confusing.

[kevmoo-old, 2013/08/08 21:23:34]

If a public member returns nothing, flag it void.

Otherwise, one is left wondering if something is returned...what it's used for,
etc.

     if (errors.length > 0) {
       throw new FormatterException.forError(errors);
     }
   }
 
   void onError(AnalysisError error) {
     errors.add(error);
   }
 
   Token tokenize(String source) {
     var scanner = new StringScanner(null, source, this);
     var token = scanner.tokenize();
     lineInfo = new LineInfo(scanner.lineStarts);
     return token;
   }
 
 }
 
 
 /// An AST visitor that drives formatting heuristics.
 class SourceVisitor implements ASTVisitor {
 
   /// The writer to which the source is to be written.
-  SourceWriter writer;
+  final SourceWriter writer;
 
   /// Cached line info for calculating blank lines.
   LineInfo lineInfo;
 
   /// Cached previous token for calculating preceding whitespace.
   Token previousToken;
 
   /// Initialize a newly created visitor to write source code representing
   /// the visited nodes to the given [writer].
   SourceVisitor(FormatterOptions options, this.lineInfo) :
@@ skipping 854 matching lines @@
       return 0;
     }
     var lastLine =
         lineInfo.getLocation(last.offset).lineNumber;
     var currentLine =
         lineInfo.getLocation(current.offset).lineNumber;
     return  currentLine - lastLine;
   }
 
 }