Paths where '..' is not right between separators are normalized.

pkg/analyzer/lib/src/util/absolute_path.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.util.absolute_path;
 
 /// The class for manipulating absolute, normalized paths.
 class AbsolutePathContext {
   static const int _COLON = 0x3A;
-  static const int _PERIOD = 0x2e;
   static const int _LOWER_A = 0x61;
   static const int _LOWER_Z = 0x7A;
   static const int _UPPER_A = 0x41;
   static const int _UPPER_Z = 0x5A;
 
   final bool _isWindows;
   String separator;
   int _separatorChar;
+  String _singlePeriodComponent;
+  String _doublePeriodComponent;
+  String _singlePeriodEnding;
+  String _doublePeriodEnding;
 
   AbsolutePathContext(this._isWindows) {
     separator = _isWindows ? r'\' : '/';
     _separatorChar = separator.codeUnitAt(0);
+    _singlePeriodComponent = separator + '.' + separator;
+    _doublePeriodComponent = separator + '..' + separator;
+    _singlePeriodEnding = separator + '.';
+    _doublePeriodEnding = separator + '..';
   }
 
   /// Append the given relative [suffix] to the given absolute [parent].
   ///
   ///     context.append('/path/to', 'foo'); // -> '/path/to/foo'
   ///
   /// The given [suffix] cannot be an absolute path or use `..`.
   String append(String parent, String suffix) {
     return '$parent$separator$suffix';
   }
@@ skipping 85 matching lines @@
     if (_isWindows) {
       return path.length >= 3 &&
           _isAlphabetic(path.codeUnitAt(0)) &&
           path.codeUnitAt(1) == _COLON &&
           path.codeUnitAt(2) == _separatorChar;
     } else {
       return path.isNotEmpty && path.codeUnitAt(0) == _separatorChar;
     }
   }
 
-
   /// Return `true` if the given absolute [path] is normalized.
   ///
   ///     _isNormalized('/foo/bar');        // -> true
   ///     _isNormalized('/foo/..bar');      // -> true
+  ///     _isNormalized('/foo/bar..');      // -> true
   ///     _isNormalized('/');               // -> true
   ///     _isNormalized('/foo/bar/../baz'); // -> false
   ///     _isNormalized('/foo/bar/..');     // -> false
   bool _isNormalized(String path) {
-    int periodCount = 0;
-    for (int c in path.codeUnits) {
-      if (c == _PERIOD) {
-        periodCount++;
-        continue;
-      }
-      if (c == _separatorChar) {
-        if (periodCount == 1 || periodCount == 2) {
-          return false;
-        }
-      }
-      periodCount = 0;
-    }
-    return periodCount != 1 && periodCount != 2;
+    return !path.contains(_singlePeriodComponent) &&
+        !path.contains(_doublePeriodComponent) &&
+        !path.endsWith(_singlePeriodEnding) &&
+        !path.endsWith(_doublePeriodEnding);
   }
 
   /// Returns whether [char] is the code for an ASCII letter (uppercase or
   /// lowercase).
   static bool _isAlphabetic(int char) {
     return char >= _UPPER_A && char <= _UPPER_Z ||
         char >= _LOWER_A && char <= _LOWER_Z;
   }
 
   /// Return `true` if [str] starts with the given [prefix].
   ///
   /// The check is done from the end of [prefix], because absolute paths
   /// usually have the same prefix, e.g. the user's home directory.
   static bool _startsWithUnsafe(String str, String prefix) {
     int len = prefix.length;
     for (int i = len - 1; i >= 0; i--) {
       if (str.codeUnitAt(i) != prefix.codeUnitAt(i)) {
         return false;
       }
     }
     return true;
   }
 }