Allow some fields to be overridden in strong mode.

lib/src/location.dart

 // Copyright (c) 2014, 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 'span.dart';
 
 // TODO(nweiz): Use SourceLocationMixin once we decide to cut a release with
 // breaking changes. See SourceLocationMixin for details.
 
 /// A class that describes a single location within a source file.
 ///
 /// This class should not be extended. Instead, [SourceLocationBase] should be
 /// extended instead.
 class SourceLocation implements Comparable<SourceLocation> {
+  // These fields go through getters so that subclasses of [SourceLocationBase]
+  // can override them.
+
   /// URL of the source containing this location.
   ///
   /// This may be null, indicating that the source URL is unknown or
   /// unavailable.
-  final Uri sourceUrl;
+  Uri get sourceUrl => _sourceUrl;
+  final Uri _sourceUrl;

[Lasse Reichstein Nielsen, 2016/03/01 15:22:42]

What does this change?

A field already introduces an implicit getter, so the external interface of the
class is unchanged by this modification.

Is it to allow subclasses inside the same package to overide the implicit
_sourceUrl getter?

The changelog text mentions strong mode. Does strong mode differentiate between
an implicit and an explicit getter? If so, it should be fixed.

[nweiz, 2016/03/01 19:16:09]

Yes, it does. I'll forward you the email thread where we discussed it.

 
   /// The 0-based offset of this location in the source.
-  final int offset;
+  int get offset => _offset;
+  final int _offset;
 
   /// The 0-based line of this location in the source.
-  final int line;
+  int get line => _line;
+  final int _line;
 
   /// The 0-based column of this location in the source
-  final int column;
+  int get column => _column;
+  final int _column;
 
   /// Returns a representation of this location in the `source:line:column`
   /// format used by text editors.
   ///
   /// This prints 1-based lines and columns.
   String get toolString {
     var source = sourceUrl == null ? 'unknown source' : sourceUrl;
     return '$source:${line + 1}:${column + 1}';
   }
 
   /// Creates a new location indicating [offset] within [sourceUrl].
   ///
   /// [line] and [column] default to assuming the source is a single line. This
   /// means that [line] defaults to 0 and [column] defaults to [offset].
   ///
   /// [sourceUrl] may be either a [String], a [Uri], or `null`.
   SourceLocation(int offset, {sourceUrl, int line, int column})
-      : sourceUrl = sourceUrl is String ? Uri.parse(sourceUrl) : sourceUrl,
-        offset = offset,
-        line = line == null ? 0 : line,
-        column = column == null ? offset : column {
+      : _sourceUrl = sourceUrl is String ? Uri.parse(sourceUrl) : sourceUrl,
+        _offset = offset,
+        _line = line == null ? 0 : line,
+        _column = column == null ? offset : column {
     if (offset < 0) {
       throw new RangeError("Offset may not be negative, was $offset.");
     } else if (line != null && line < 0) {
       throw new RangeError("Line may not be negative, was $line.");
     } else if (column != null && column < 0) {
       throw new RangeError("Column may not be negative, was $column.");
     }
   }
 
   /// Returns the distance in characters between [this] and [other].
@@ skipping 29 matching lines @@
 
   String toString() => '<$runtimeType: $offset $toolString>';
 }
 
 /// A base class for source locations with [offset], [line], and [column] known
 /// at construction time.
 class SourceLocationBase extends SourceLocation {
   SourceLocationBase(int offset, {sourceUrl, int line, int column})
       : super(offset, sourceUrl: sourceUrl, line: line, column: column);
 }