[Indented syntax improvements] Dart implementation

CHANGELOG.md

@@ -1,3 +1,10 @@
+## 1.84.0-dev
+
+* Allow newlines in whitespace in the indented syntax.
+
+* **Potentially breaking bug fix**: Selectors with unmatched brackets now always
+  produce a parser error. Previously, some edge cases like `[foo#{"]:is(bar"}) {a:
+  b}` would compile without error, but this was an unintentional bug.
 ## 1.83.5-dev
 
 * Fix the error message for `@extend` without a selector and possibly other

lib/src/parse/at_root_query.dart

@@ -14,22 +14,27 @@ class AtRootQueryParser extends Parser {
   AtRootQuery parse() {
     return wrapSpanFormatException(() {
       scanner.expectChar($lparen);
-      whitespace();
+      _whitespace();
       var include = scanIdentifier("with");
       if (!include) expectIdentifier("without", name: '"with" or "without"');
-      whitespace();
+      _whitespace();
       scanner.expectChar($colon);
-      whitespace();
+      _whitespace();
 
       var atRules = <String>{};
       do {
         atRules.add(identifier().toLowerCase());
-        whitespace();
+        _whitespace();
       } while (lookingAtIdentifier());
       scanner.expectChar($rparen);
       scanner.expectDone();
 
       return AtRootQuery(atRules, include: include);
     });
   }
+
+  /// The value of `consumeNewlines` is not relevant for this class.
+  void _whitespace() {
+    whitespace(consumeNewlines: true);
+  }
 }

lib/src/parse/css.dart

@@ -49,7 +49,7 @@ class CssParser extends ScssParser {
     var start = scanner.state;
     scanner.expectChar($at);
     var name = interpolatedIdentifier();
-    whitespace();
+    _whitespace();
 
     return switch (name.asPlain) {
       "at-root" ||
@@ -113,7 +113,7 @@ class CssParser extends ScssParser {
           .text
     };
 
-    whitespace();
+    _whitespace();
     var modifiers = tryImportModifiers();
     expectStatementSeparator("@import rule");
     return ImportRule(
@@ -126,7 +126,7 @@ class CssParser extends ScssParser {
     // evaluation time.
     var start = scanner.state;
     scanner.expectChar($lparen);
-    whitespace();
+    _whitespace();
     var expression = expressionUntilComma();
     scanner.expectChar($rparen);
     return ParenthesizedExpression(expression, scanner.spanFrom(start));
@@ -151,7 +151,7 @@ class CssParser extends ScssParser {
     var arguments = <Expression>[];
     if (!scanner.scanChar($rparen)) {
       do {
-        whitespace();
+        _whitespace();
         if (allowEmptySecondArg &&
             arguments.length == 1 &&
             scanner.peekChar() == $rparen) {
@@ -160,7 +160,7 @@ class CssParser extends ScssParser {
         }
 
         arguments.add(expressionUntilComma(singleEquals: true));
-        whitespace();
+        _whitespace();
       } while (scanner.scanChar($comma));
       scanner.expectChar($rparen);
     }
@@ -180,4 +180,9 @@ class CssParser extends ScssParser {
     var expression = super.namespacedExpression(namespace, start);
     error("Module namespaces aren't allowed in plain CSS.", expression.span);
   }
+
+  /// The value of `consumeNewlines` is not relevant for this class.
+  void _whitespace() {
+    whitespace(consumeNewlines: true);
+  }
 }

lib/src/parse/keyframe_selector.dart

@@ -15,7 +15,7 @@ class KeyframeSelectorParser extends Parser {
     return wrapSpanFormatException(() {
       var selectors = <String>[];
       do {
-        whitespace();
+        _whitespace();
         if (lookingAtIdentifier()) {
           if (scanIdentifier("from")) {
             selectors.add("from");
@@ -26,7 +26,7 @@ class KeyframeSelectorParser extends Parser {
         } else {
           selectors.add(_percentage());
         }
-        whitespace();
+        _whitespace();
       } while (scanner.scanChar($comma));
       scanner.expectDone();
 
@@ -71,4 +71,9 @@ class KeyframeSelectorParser extends Parser {
     buffer.writeCharCode($percent);
     return buffer.toString();
   }
+
+  /// The value of `consumeNewlines` is not relevant for this class.
+  void _whitespace() {
+    whitespace(consumeNewlines: true);
+  }
 }

lib/src/parse/media_query.dart

@@ -16,9 +16,9 @@ class MediaQueryParser extends Parser {
     return wrapSpanFormatException(() {
       var queries = <CssMediaQuery>[];
       do {
-        whitespace();
+        _whitespace();
         queries.add(_mediaQuery());
-        whitespace();
+        _whitespace();
       } while (scanner.scanChar($comma));
       scanner.expectDone();
       return queries;
@@ -30,7 +30,7 @@ class MediaQueryParser extends Parser {
     // This is somewhat duplicated in StylesheetParser._mediaQuery.
     if (scanner.peekChar() == $lparen) {
       var conditions = [_mediaInParens()];
-      whitespace();
+      _whitespace();
 
       var conjunction = true;
       if (scanIdentifier("and")) {
@@ -57,7 +57,7 @@ class MediaQueryParser extends Parser {
       }
     }
 
-    whitespace();
+    _whitespace();
     if (!lookingAtIdentifier()) {
       // For example, "@media screen {"
       return CssMediaQuery.type(identifier1);
@@ -70,7 +70,7 @@ class MediaQueryParser extends Parser {
       // For example, "@media screen and ..."
       type = identifier1;
     } else {
-      whitespace();
+      _whitespace();
       modifier = identifier1;
       type = identifier2;
       if (scanIdentifier("and")) {
@@ -102,7 +102,7 @@ class MediaQueryParser extends Parser {
     var result = <String>[];
     while (true) {
       result.add(_mediaInParens());
-      whitespace();
+      _whitespace();
 
       if (!scanIdentifier(operator)) return result;
       expectWhitespace();
@@ -117,4 +117,9 @@ class MediaQueryParser extends Parser {
     scanner.expectChar($rparen);
     return result;
   }
+
+  /// The value of `consumeNewlines` is not relevant for this class.
+  void _whitespace() {
+    whitespace(consumeNewlines: true);
+  }
 }

lib/src/parse/parser.dart

@@ -67,23 +67,31 @@ class Parser {
     if (!scanner.scanChar($dollar)) return false;
     if (!lookingAtIdentifier()) return false;
     identifier();
-    whitespace();
+    whitespace(consumeNewlines: true);
     return scanner.scanChar($colon);
   }
 
   // ## Tokens
 
   /// Consumes whitespace, including any comments.
+  ///
+  /// If [consumeNewlines] is `true`, the indented syntax will consume newlines
+  /// as whitespace. It should only be set to `true` in positions when a
+  /// statement can't end.
   @protected
-  void whitespace() {
+  void whitespace({required bool consumeNewlines}) {
     do {
-      whitespaceWithoutComments();
+      whitespaceWithoutComments(consumeNewlines: consumeNewlines);
     } while (scanComment());
   }
 
   /// Consumes whitespace, but not comments.
+  ///
+  /// If [consumeNewlines] is `true`, the indented syntax will consume newlines
+  /// as whitespace. It should only be set to `true` in positions when a
+  /// statement can't end.
   @protected
-  void whitespaceWithoutComments() {
+  void whitespaceWithoutComments({required bool consumeNewlines}) {
     while (!scanner.isDone && scanner.peekChar().isWhitespace) {
       scanner.readChar();
     }
@@ -116,13 +124,16 @@ class Parser {
   }
 
   /// Like [whitespace], but throws an error if no whitespace is consumed.
+  ///
+  /// If [consumeNewlines] is `true`, the indented syntax will consume newlines
+  /// as whitespace. It should only be set to `true` in positions when a
+  /// statement can't end.
   @protected
-  void expectWhitespace() {
+  void expectWhitespace({bool consumeNewlines = false}) {
     if (scanner.isDone || !(scanner.peekChar().isWhitespace || scanComment())) {
       scanner.error("Expected whitespace.");
     }
-
-    whitespace();
+    whitespace(consumeNewlines: consumeNewlines);
   }
 
   /// Consumes and ignores a single silent (Sass-style) comment, not including
@@ -386,7 +397,7 @@ class Parser {
       return null;
     }
 
-    whitespace();
+    whitespace(consumeNewlines: true);
 
     // Match Ruby Sass's behavior: parse a raw URL() if possible, and if not
     // backtrack and re-parse as a function expression.
@@ -407,7 +418,7 @@ class Parser {
               >= 0x0080:
           buffer.writeCharCode(scanner.readChar());
         case int(isWhitespace: true):
-          whitespace();
+          whitespace(consumeNewlines: true);
           if (scanner.peekChar() != $rparen) break loop;
         case $rparen:
           buffer.writeCharCode(scanner.readChar());

lib/src/parse/sass.dart

@@ -54,7 +54,10 @@ class SassParser extends StylesheetParser {
   }
 
   void expectStatementSeparator([String? name]) {
-    if (!atEndOfStatement()) _expectNewline();
+    var trailingSemicolon = _tryTrailingSemicolon();
+    if (!atEndOfStatement()) {
+      _expectNewline(trailingSemicolon: trailingSemicolon);
+    }
     if (_peekIndentation() <= currentIndentation) return;
     scanner.error(
         "Nothing may be indented ${name == null ? 'here' : 'beneath a $name'}.",
@@ -259,7 +262,7 @@ class SassParser extends StylesheetParser {
               buffer.writeCharCode(scanner.readChar());
               buffer.writeCharCode(scanner.readChar());
               var span = scanner.spanFrom(start);
-              whitespace();
+              whitespace(consumeNewlines: false);
 
               // For backwards compatibility, allow additional comments after
               // the initial comment is closed.
@@ -269,7 +272,7 @@ class SassParser extends StylesheetParser {
                   _expectNewline();
                 }
                 _readIndentation();
-                whitespace();
+                whitespace(consumeNewlines: false);
               }
 
               if (!scanner.isDone && !scanner.peekChar().isNewline) {
@@ -309,37 +312,22 @@ class SassParser extends StylesheetParser {
     return LoudComment(buffer.interpolation(scanner.spanFrom(start)));
   }
 
-  void whitespaceWithoutComments() {
-    // This overrides whitespace consumption so that it doesn't consume
-    // newlines.
+  void whitespaceWithoutComments({required bool consumeNewlines}) {
+    // This overrides whitespace consumption to only consume newlines when
+    // `consumeNewlines` is true.
     while (!scanner.isDone) {
       var next = scanner.peekChar();
-      if (next != $tab && next != $space) break;
+      if (consumeNewlines ? !next.isWhitespace : !next.isSpaceOrTab) break;
       scanner.readChar();
     }
   }
 
-  void loudComment() {
-    // This overrides loud comment consumption so that it doesn't consume
-    // multi-line comments.
-    scanner.expect("/*");
-    while (true) {
-      var next = scanner.readChar();
-      if (next.isNewline) scanner.error("expected */.");
-      if (next != $asterisk) continue;
-
-      do {
-        next = scanner.readChar();
-      } while (next == $asterisk);
-      if (next == $slash) break;
-    }
-  }
-
   /// Expect and consume a single newline character.
-  void _expectNewline() {
+  ///
+  /// If [trailingSemicolon] is true, this follows a semicolon, which is used
+  /// for error reporting.
+  void _expectNewline({bool trailingSemicolon = false}) {
     switch (scanner.peekChar()) {
-      case $semicolon:
-        scanner.error("semicolons aren't allowed in the indented syntax.");
       case $cr:
         scanner.readChar();
         if (scanner.peekChar() == $lf) scanner.readChar();
@@ -348,7 +336,9 @@ class SassParser extends StylesheetParser {
         scanner.readChar();
         return;
       default:
-        scanner.error("expected newline.");
+        scanner.error(trailingSemicolon
+            ? "multiple statements on one line are not supported in the indented syntax."
+            : "expected newline.");
     }
   }
 
@@ -467,4 +457,15 @@ class SassParser extends StylesheetParser {
           position: scanner.position - scanner.column, length: scanner.column);
     }
   }
+
+  /// Consumes a semicolon and trailing whitespace, including comments.
+  ///
+  /// Returns whether a semicolon was consumed.
+  bool _tryTrailingSemicolon() {
+    if (scanCharIf((char) => char == $semicolon)) {
+      whitespace(consumeNewlines: false);
+      return true;
+    }
+    return false;
+  }
 }