Merge origin/main into feature.color-4

.pubignore

@@ -1,5 +1,5 @@
 # This should be identical to .gitignore except that it doesn't exclude
-# generated protobuf files.
+# generated Dart files.
 
 .buildlog
 .DS_Store

CHANGELOG.md

@@ -1,4 +1,4 @@
-## 1.76.0
+## 1.78.0
 
 * **Breaking change**: Passing a number with unit `%` to the `$alpha` parameter
   of `color.change()`, `color.adjust()`, `change-color()`, and `adjust-color()`
@@ -184,6 +184,44 @@
 
 * Remove `RgbColor`, `HslColor` and `HwbColor` SassScript values.
 
+## 1.77.3
+
+### Dart API
+
+* `Deprecation.duplicateVariableFlags` has been deprecated and replaced with
+  `Deprecation.duplicateVarFlags` to make it consistent with the
+  `duplicate-var-flags` name used on the command line and in the JS API.
+
+## 1.77.2
+
+* Don't emit deprecation warnings for functions and mixins beginning with `__`.
+
+* Allow user-defined functions whose names begin with `_` and otherwise look
+  like vendor-prefixed functions with special CSS syntax.
+
+### Command-Line Interface
+
+* Properly handle the `--silence-deprecation` flag.
+
+* Handle the `--fatal-deprecation` and `--future-deprecation` flags for
+  `--interactive` mode.
+
+## 1.77.1
+
+* Fix a crash that could come up with importers in certain contexts.
+
+## 1.77.0
+
+* *Don't* throw errors for at-rules in keyframe blocks.
+
+## 1.76.0
+
+* Throw errors for misplaced statements in keyframe blocks.
+
+* Mixins and functions whose names begin with `--` are now deprecated for
+  forwards-compatibility with the in-progress CSS functions and mixins spec.
+  This deprecation is named `css-function-mixin`.
+
 ## 1.75.0
 
 * Fix a bug in which stylesheet canonicalization could be cached incorrectly

README.md

@@ -42,6 +42,7 @@ A [Dart][dart] implementation of [Sass][sass]. **Sass makes CSS fun**.
 * [Compatibility Policy](#compatibility-policy)
   * [Browser Compatibility](#browser-compatibility)
   * [Node.js Compatibility](#nodejs-compatibility)
+  * [Invalid CSS](#invalid-css)
 * [Embedded Dart Sass](#embedded-dart-sass)
   * [Usage](#usage)
 * [Behavioral Differences from Ruby Sass](#behavioral-differences-from-ruby-sass)
@@ -405,6 +406,18 @@ considers itself free to break support if necessary.
 
 [the Node.js release page]: https://nodejs.org/en/about/previous-releases
 
+### Invalid CSS
+
+Changes to the behavior of Sass stylesheets that produce invalid CSS output are
+_not_ considered breaking changes. Such changes are almost always necessary when
+adding support for new CSS features, and delaying all such features until a new
+major version would be unduly burdensome for most users.
+
+For example, when Sass began parsing `calc()` expressions, the invalid
+expression `calc(1 +)` became a Sass error where before it was passed through
+as-is. This was not considered a breaking change, because `calc(1 +)` was never
+valid CSS to begin with.
+
 ## Embedded Dart Sass
 
 Dart Sass includes an implementation of the compiler side of the [Embedded Sass

lib/src/ast/sass/expression/function.dart

@@ -23,6 +23,12 @@ final class FunctionExpression
   /// without a namespace.
   final String? namespace;
 
+  /// The name of the function being invoked, with underscores converted to
+  /// hyphens.
+  ///
+  /// If this function is a plain CSS function, use [originalName] instead.
+  final String name;
+
   /// The name of the function being invoked, with underscores left as-is.
   final String originalName;
 
@@ -31,12 +37,6 @@ final class FunctionExpression
 
   final FileSpan span;
 
-  /// The name of the function being invoked, with underscores converted to
-  /// hyphens.
-  ///
-  /// If this function is a plain CSS function, use [originalName] instead.
-  String get name => originalName.replaceAll('_', '-');
-
   FileSpan get nameSpan {
     if (namespace == null) return span.initialIdentifier();
     return span.withoutNamespace().initialIdentifier();
@@ -46,7 +46,8 @@ final class FunctionExpression
       namespace == null ? null : span.initialIdentifier();
 
   FunctionExpression(this.originalName, this.arguments, this.span,
-      {this.namespace});
+      {this.namespace})
+      : name = originalName.replaceAll('_', '-');
 
   T accept<T>(ExpressionVisitor<T> visitor) =>
       visitor.visitFunctionExpression(this);

lib/src/ast/sass/statement/callable_declaration.dart

@@ -18,6 +18,9 @@ abstract base class CallableDeclaration
   /// The name of this callable, with underscores converted to hyphens.
   final String name;
 
+  /// The callable's original name, without underscores converted to hyphens.
+  final String originalName;
+
   /// The comment immediately preceding this declaration.
   final SilentComment? comment;
 
@@ -26,8 +29,9 @@ abstract base class CallableDeclaration
 
   final FileSpan span;
 
-  CallableDeclaration(
-      this.name, this.arguments, Iterable<Statement> children, this.span,
+  CallableDeclaration(this.originalName, this.arguments,
+      Iterable<Statement> children, this.span,
       {this.comment})
-      : super(List.unmodifiable(children));
+      : name = originalName.replaceAll('_', '-'),
+        super(List.unmodifiable(children));
 }

lib/src/ast/sass/statement/include_rule.dart

@@ -25,6 +25,10 @@ final class IncludeRule
   /// hyphens.
   final String name;
 
+  /// The original name of the mixin being invoked, without underscores
+  /// converted to hyphens.
+  final String originalName;
+
   /// The arguments to pass to the mixin.
   final ArgumentInvocation arguments;
 
@@ -55,8 +59,9 @@ final class IncludeRule
     return startSpan.initialIdentifier();
   }
 
-  IncludeRule(this.name, this.arguments, this.span,
-      {this.namespace, this.content});
+  IncludeRule(this.originalName, this.arguments, this.span,
+      {this.namespace, this.content})
+      : name = originalName.replaceAll('_', '-');
 
   T accept<T>(StatementVisitor<T> visitor) => visitor.visitIncludeRule(this);
 

lib/src/async_import_cache.dart

@@ -11,10 +11,12 @@ import 'package:path/path.dart' as p;
 import 'ast/sass.dart';
 import 'deprecation.dart';
 import 'importer.dart';
+import 'importer/canonicalize_context.dart';
 import 'importer/no_op.dart';
 import 'importer/utils.dart';
 import 'io.dart';
 import 'logger.dart';
+import 'util/map.dart';
 import 'util/nullable.dart';
 import 'utils.dart';
 
@@ -43,30 +45,28 @@ final class AsyncImportCache {
   /// The `forImport` in each key is true when this canonicalization is for an
   /// `@import` rule. Otherwise, it's for a `@use` or `@forward` rule.
   ///
-  /// This cache isn't used for relative imports, because they depend on the
-  /// specific base importer. That's stored separately in
-  /// [_relativeCanonicalizeCache].
+  /// This cache covers loads that go through the entire chain of [_importers],
+  /// but it doesn't cover individual loads or loads in which any importer
+  /// accesses `containingUrl`. See also [_perImporterCanonicalizeCache].
   final _canonicalizeCache =
       <(Uri, {bool forImport}), AsyncCanonicalizeResult?>{};
 
-  /// The canonicalized URLs for each non-canonical URL that's resolved using a
-  /// relative importer.
+  /// Like [_canonicalizeCache] but also includes the specific importer in the
+  /// key.
   ///
-  /// The map's keys have four parts:
+  /// This is used to cache both relative imports from the base importer and
+  /// individual importer results in the case where some other component of the
+  /// importer chain isn't cacheable.
+  final _perImporterCanonicalizeCache =
+      <(AsyncImporter, Uri, {bool forImport}), AsyncCanonicalizeResult?>{};
+
+  /// A map from the keys in [_perImporterCanonicalizeCache] that are generated
+  /// for relative URL loads agains the base importer to the original relative
+  /// URLs what were loaded.
   ///
-  /// 1. The URL passed to [canonicalize] (the same as in [_canonicalizeCache]).
-  /// 2. Whether the canonicalization is for an `@import` rule.
-  /// 3. The `baseImporter` passed to [canonicalize].
-  /// 4. The `baseUrl` passed to [canonicalize].
-  ///
-  /// The map's values are the same as the return value of [canonicalize].
-  final _relativeCanonicalizeCache = <(
-    Uri, {
-    bool forImport,
-    AsyncImporter baseImporter,
-    Uri? baseUrl
-  }),
-      AsyncCanonicalizeResult?>{};
+  /// This is used to invalidate the cache when files are changed.
+  final _nonCanonicalRelativeUrls =
+      <(AsyncImporter, Uri, {bool forImport}), Uri>{};
 
   /// The parsed stylesheets for each canonicalized import URL.
   final _importCache = <Uri, Stylesheet?>{};
@@ -154,18 +154,17 @@ final class AsyncImportCache {
     }
 
     if (baseImporter != null && url.scheme == '') {
-      var relativeResult = await putIfAbsentAsync(_relativeCanonicalizeCache, (
-        url,
-        forImport: forImport,
-        baseImporter: baseImporter,
-        baseUrl: baseUrl
-      ), () async {
-        var (result, cacheable) = await _canonicalize(
-            baseImporter, baseUrl?.resolveUri(url) ?? url, baseUrl, forImport);
+      var resolvedUrl = baseUrl?.resolveUri(url) ?? url;
+      var key = (baseImporter, resolvedUrl, forImport: forImport);
+      var relativeResult =
+          await putIfAbsentAsync(_perImporterCanonicalizeCache, key, () async {
+        var (result, cacheable) =
+            await _canonicalize(baseImporter, resolvedUrl, baseUrl, forImport);
         assert(
             cacheable,
             "Relative loads should always be cacheable because they never "
             "provide access to the containing URL.");
+        if (baseUrl != null) _nonCanonicalRelativeUrls[key] = url;
         return result;
       });
       if (relativeResult != null) return relativeResult;
@@ -181,17 +180,41 @@ final class AsyncImportCache {
     // `canonicalize()` calls we've attempted are cacheable. Only if they are do
     // we store the result in the cache.
     var cacheable = true;
-    for (var importer in _importers) {
+    for (var i = 0; i < _importers.length; i++) {
+      var importer = _importers[i];
+      var perImporterKey = (importer, url, forImport: forImport);
+      switch (_perImporterCanonicalizeCache.getOption(perImporterKey)) {
+        case (var result?,):
+          return result;
+        case (null,):
+          continue;
+      }
+
       switch (await _canonicalize(importer, url, baseUrl, forImport)) {
         case (var result?, true) when cacheable:
           _canonicalizeCache[key] = result;
           return result;
 
-        case (var result?, _):
-          return result;
-
-        case (_, false):
-          cacheable = false;
+        case (var result, true) when !cacheable:
+          _perImporterCanonicalizeCache[perImporterKey] = result;
+          if (result != null) return result;
+
+        case (var result, false):
+          if (cacheable) {
+            // If this is the first uncacheable result, add all previous results
+            // to the per-importer cache so we don't have to re-run them for
+            // future uses of this importer.
+            for (var j = 0; j < i; j++) {
+              _perImporterCanonicalizeCache[(
+                _importers[j],
+                url,
+                forImport: forImport
+              )] = null;
+            }
+            cacheable = false;
+          }
+
+          if (result != null) return result;
       }
     }
 
@@ -206,18 +229,17 @@ final class AsyncImportCache {
   /// that result is cacheable at all.
   Future<(AsyncCanonicalizeResult?, bool cacheable)> _canonicalize(
       AsyncImporter importer, Uri url, Uri? baseUrl, bool forImport) async {
-    var canonicalize = forImport
-        ? () => inImportRule(() => importer.canonicalize(url))
-        : () => importer.canonicalize(url);
-
     var passContainingUrl = baseUrl != null &&
         (url.scheme == '' || await importer.isNonCanonicalScheme(url.scheme));
-    var result = await withContainingUrl(
-        passContainingUrl ? baseUrl : null, canonicalize);
 
-    // TODO(sass/dart-sass#2208): Determine whether the containing URL was
-    // _actually_ accessed rather than assuming it was.
-    var cacheable = !passContainingUrl || importer is FilesystemImporter;
+    var canonicalizeContext =
+        CanonicalizeContext(passContainingUrl ? baseUrl : null, forImport);
+
+    var result = await withCanonicalizeContext(
+        canonicalizeContext, () => importer.canonicalize(url));
+
+    var cacheable =
+        !passContainingUrl || !canonicalizeContext.wasContainingUrlAccessed;
 
     if (result == null) return (null, cacheable);
 
@@ -315,7 +337,7 @@ final class AsyncImportCache {
   Uri sourceMapUrl(Uri canonicalUrl) =>
       _resultsCache[canonicalUrl]?.sourceMapUrl ?? canonicalUrl;
 
-  /// Clears the cached canonical version of the given [url].
+  /// Clears the cached canonical version of the given non-canonical [url].
   ///
   /// Has no effect if the canonical version of [url] has not been cached.
   ///
@@ -324,7 +346,8 @@ final class AsyncImportCache {
   void clearCanonicalize(Uri url) {
     _canonicalizeCache.remove((url, forImport: false));
     _canonicalizeCache.remove((url, forImport: true));
-    _relativeCanonicalizeCache.removeWhere((key, _) => key.$1 == url);
+    _perImporterCanonicalizeCache.removeWhere(
+        (key, _) => key.$2 == url || _nonCanonicalRelativeUrls[key] == url);
   }
 
   /// Clears the cached parse tree for the stylesheet with the given