implement first class mixins

lib/src/callable/built_in.dart

@@ -21,6 +21,8 @@ final class BuiltInCallable implements Callable, AsyncBuiltInCallable {
   /// The overloads declared for this callable.
   final List<(ArgumentDeclaration, Callback)> _overloads;
 
+  bool hasContent = false;
+
   /// Creates a function with a single [arguments] declaration and a single
   /// [callback].
   ///
@@ -48,18 +50,19 @@ final class BuiltInCallable implements Callable, AsyncBuiltInCallable {
   /// defined.
   BuiltInCallable.mixin(
       String name, String arguments, void callback(List<Value> arguments),
-      {Object? url})
+      {Object? url, bool hasContent = false})
       : this.parsed(name,
             ArgumentDeclaration.parse('@mixin $name($arguments) {', url: url),
             (arguments) {
           callback(arguments);
           return sassNull;
-        });
+        }, hasContent: hasContent);
 
   /// Creates a callable with a single [arguments] declaration and a single
   /// [callback].
   BuiltInCallable.parsed(this.name, ArgumentDeclaration arguments,
-      Value callback(List<Value> arguments))
+      Value callback(List<Value> arguments),
+      {this.hasContent = false})
       : _overloads = [(arguments, callback)];
 
   /// Creates a function with multiple implementations.

lib/src/embedded/dispatcher.dart

@@ -18,6 +18,7 @@ import 'host_callable.dart';
 import 'importer/file.dart';
 import 'importer/host.dart';
 import 'logger.dart';
+import 'mixin_registry.dart';
 import 'util/proto_extensions.dart';
 import 'utils.dart';
 
@@ -126,6 +127,7 @@ final class Dispatcher {
   Future<OutboundMessage_CompileResponse> _compile(
       InboundMessage_CompileRequest request) async {
     var functions = FunctionRegistry();
+    var mixins = MixinRegistry();
 
     var style = request.style == OutputStyle.COMPRESSED
         ? sass.OutputStyle.compressed
@@ -139,7 +141,7 @@ final class Dispatcher {
           (throw mandatoryError("Importer.importer")));
 
       var globalFunctions = request.globalFunctions
-          .map((signature) => hostCallable(this, functions, signature));
+          .map((signature) => hostCallable(this, functions, mixins, signature));
 
       late sass.CompileResult result;
       switch (request.whichInput()) {

lib/src/embedded/host_callable.dart

@@ -5,6 +5,8 @@
 // ignore: deprecated_member_use
 import 'dart:cli';
 
+import 'package:sass/src/embedded/mixin_registry.dart';
+
 import '../callable.dart';
 import '../exception.dart';
 import 'dispatcher.dart';
@@ -21,12 +23,12 @@ import 'utils.dart';
 /// the name defined in the [signature].
 ///
 /// Throws a [SassException] if [signature] is invalid.
-Callable hostCallable(
-    Dispatcher dispatcher, FunctionRegistry functions, String signature,
+Callable hostCallable(Dispatcher dispatcher, FunctionRegistry functions,
+    MixinRegistry mixins, String signature,
     {int? id}) {
   late Callable callable;
   callable = Callable.fromSignature(signature, (arguments) {
-    var protofier = Protofier(dispatcher, functions);
+    var protofier = Protofier(dispatcher, functions, mixins);
     var request = OutboundMessage_FunctionCallRequest()
       ..arguments.addAll(
           [for (var argument in arguments) protofier.protofy(argument)]);

lib/src/embedded/mixin_registry.dart

@@ -0,0 +1,33 @@
+// Copyright 2019 Google Inc. Use of this source code is governed by an
+// MIT-style license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+import '../value/mixin.dart';
+import 'embedded_sass.pb.dart';
+
+/// A registry of [SassMixin]s indexed by ID so that the host can invoke
+/// them.
+final class MixinRegistry {
+  /// First-class mixins that have been sent to the host.
+  ///
+  /// The mixins are located at indexes in the list matching their IDs.
+  final _mixinsById = <SassMixin>[];
+
+  /// A reverse map from mixins to their indexes in [_mixinsById].
+  final _idsByMixin = <SassMixin, int>{};
+
+  /// Converts [mixin] to a protocol buffer to send to the host.
+  Value_CompilerMixin protofy(SassMixin mixin) {
+    var id = _idsByMixin.putIfAbsent(mixin, () {
+      _mixinsById.add(mixin);
+      return _mixinsById.length - 1;
+    });
+
+    return Value_CompilerMixin()..id = id;
+  }
+
+  /// Returns the compiler-side mixin associated with [id].
+  ///
+  /// If no such mixin exists, returns `null`.
+  SassMixin? operator [](int id) => _mixinsById[id];
+}

lib/src/embedded/protofier.dart

@@ -9,6 +9,7 @@ import 'dispatcher.dart';
 import 'embedded_sass.pb.dart' as proto;
 import 'embedded_sass.pb.dart' hide Value, ListSeparator, CalculationOperator;
 import 'function_registry.dart';
+import 'mixin_registry.dart';
 import 'host_callable.dart';
 import 'utils.dart';
 
@@ -23,6 +24,9 @@ final class Protofier {
   /// The IDs of first-class functions.
   final FunctionRegistry _functions;
 
+  /// The IDs of first-class mixins.
+  final MixinRegistry _mixins;
+
   /// Any argument lists transitively contained in [value].
   ///
   /// The IDs of the [Value_ArgumentList] protobufs are always one greater than
@@ -35,7 +39,10 @@ final class Protofier {
   ///
   /// The [functions] tracks the IDs of first-class functions so that the host
   /// can pass them back to the compiler.
-  Protofier(this._dispatcher, this._functions);
+  ///
+  /// Similarly, the [mixins] tracks the IDs of first-class mixins so that the
+  /// host can pass them back to the compiler.
+  Protofier(this._dispatcher, this._functions, this._mixins);
 
   /// Converts [value] to its protocol buffer representation.
   proto.Value protofy(Value value) {
@@ -85,6 +92,8 @@ final class Protofier {
         result.calculation = _protofyCalculation(value);
       case SassFunction():
         result.compilerFunction = _functions.protofy(value);
+      case SassMixin():
+        result.compilerMixin = _mixins.protofy(value);
       case sassTrue:
         result.singleton = SingletonValue.TRUE;
       case sassFalse:
@@ -240,9 +249,15 @@ final class Protofier {
 
         case Value_Value.hostFunction:
           return SassFunction(hostCallable(
-              _dispatcher, _functions, value.hostFunction.signature,
+              _dispatcher, _functions, _mixins, value.hostFunction.signature,
               id: value.hostFunction.id));
 
+        case Value_Value.compilerMixin:
+          var id = value.compilerMixin.id;
+          if (_mixins[id] case var mixin?) return mixin;
+          throw paramsError(
+              "CompilerMixin.id $id doesn't match any known mixins");
+
         case Value_Value.calculation:
           return _deprotofyCalculation(value.calculation);
 

lib/src/functions/meta.dart

@@ -6,6 +6,7 @@ import 'dart:collection';
 
 import 'package:collection/collection.dart';
 
+import '../ast/sass/statement/mixin_rule.dart';
 import '../callable.dart';
 import '../util/map.dart';
 import '../value.dart';
@@ -45,6 +46,7 @@ final global = UnmodifiableListView([
             sassNull => "null",
             SassNumber() => "number",
             SassFunction() => "function",
+            SassMixin() => "mixin",
             SassCalculation() => "calculation",
             SassString() => "string",
             _ => throw "[BUG] Unknown value type ${arguments[0]}"
@@ -77,6 +79,17 @@ final local = UnmodifiableListView([
             ? argument
             : SassString(argument.toString(), quotes: false)),
         ListSeparator.comma);
+  }),
+  _function("accepts-content", r"$mixin", (arguments) {
+    var mixin = arguments[0].assertMixin("mixin");
+    bool acceptsContent = switch (mixin.callable) {
+      BuiltInCallable(hasContent: var hasContent) => hasContent,
+      UserDefinedCallable(declaration: MixinRule(hasContent: var hasContent)) =>
+        hasContent,
+      AsyncCallable() =>
+        throw UnsupportedError("Unknown callable type $mixin."),
+    };
+    return SassBoolean(acceptsContent);
   })
 ]);
 

lib/src/js.dart

@@ -32,6 +32,7 @@ void main() {
   exports.CalculationInterpolation = calculationInterpolationClass;
   exports.SassColor = colorClass;
   exports.SassFunction = functionClass;
+  exports.SassMixin = mixinClass;
   exports.SassList = listClass;
   exports.SassMap = mapClass;
   exports.SassNumber = numberClass;

lib/src/js/exports.dart

@@ -32,6 +32,7 @@ class Exports {
   external set SassBoolean(JSClass function);
   external set SassColor(JSClass function);
   external set SassFunction(JSClass function);
+  external set SassMixin(JSClass mixin);
   external set SassList(JSClass function);
   external set SassMap(JSClass function);
   external set SassNumber(JSClass function);

lib/src/js/value.dart

@@ -15,6 +15,7 @@ export 'value/color.dart';
 export 'value/function.dart';
 export 'value/list.dart';
 export 'value/map.dart';
+export 'value/mixin.dart';
 export 'value/number.dart';
 export 'value/string.dart';
 
@@ -42,6 +43,7 @@ final JSClass valueClass = () {
     'assertColor': (Value self, [String? name]) => self.assertColor(name),
     'assertFunction': (Value self, [String? name]) => self.assertFunction(name),
     'assertMap': (Value self, [String? name]) => self.assertMap(name),
+    'assertMixin': (Value self, [String? name]) => self.assertMixin(name),
     'assertNumber': (Value self, [String? name]) => self.assertNumber(name),
     'assertString': (Value self, [String? name]) => self.assertString(name),
     'tryMap': (Value self) => self.tryMap(),

lib/src/js/value/mixin.dart

@@ -0,0 +1,22 @@
+// Copyright 2021 Google Inc. Use of this source code is governed by an
+// MIT-style license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+import 'package:node_interop/js.dart';
+
+import '../../callable.dart';
+import '../../value.dart';
+import '../reflection.dart';
+import '../utils.dart';
+
+/// The JavaScript `SassMixin` class.
+final JSClass mixinClass = () {
+  var jsClass = createJSClass('sass.SassMixin', () {
+    jsThrow(JsError(
+        'It is not possible to construct a SassMixin through the JavaScript API'));
+  });
+
+  getJSClass(SassMixin(Callable('f', '', (_) => sassNull)))
+      .injectSuperclass(jsClass);
+  return jsClass;
+}();

lib/src/value.dart

@@ -15,6 +15,7 @@ import 'value/color.dart';
 import 'value/function.dart';
 import 'value/list.dart';
 import 'value/map.dart';
+import 'value/mixin.dart';
 import 'value/number.dart';
 import 'value/string.dart';
 import 'visitor/interface/value.dart';
@@ -27,6 +28,7 @@ export 'value/color.dart';
 export 'value/function.dart';
 export 'value/list.dart';
 export 'value/map.dart';
+export 'value/mixin.dart';
 export 'value/null.dart';
 export 'value/number.dart' hide conversionFactor;
 export 'value/string.dart';
@@ -177,6 +179,13 @@ abstract class Value {
   SassFunction assertFunction([String? name]) =>
       throw SassScriptException("$this is not a function reference.", name);
 
+  /// Throws a [SassScriptException] if [this] isn't a mixin reference.
+  ///
+  /// If this came from a mixin argument, [name] is the argument name
+  /// (without the `$`). It's used for error reporting.
+  SassMixin assertMixin([String? name]) =>
+      throw SassScriptException("$this is not a mixin reference.", name);
+
   /// Throws a [SassScriptException] if [this] isn't a map.
   ///
   /// If this came from a function argument, [name] is the argument name

lib/src/value/mixin.dart

@@ -0,0 +1,38 @@
+// Copyright 2016 Google Inc. Use of this source code is governed by an
+// MIT-style license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+import 'package:meta/meta.dart';
+
+import '../callable.dart';
+import '../visitor/interface/value.dart';
+import '../value.dart';
+
+/// A SassScript mixin reference.
+///
+/// A mixin reference captures a mixin from the local environment so that
+/// it may be passed between modules.
+///
+/// {@category Value}
+@sealed
+class SassMixin extends Value {
+  /// The callable that this mixin invokes.
+  ///
+  /// Note that this is typed as an [AsyncCallable] so that it will work with
+  /// both synchronous and asynchronous evaluate visitors, but in practice the
+  /// synchronous evaluate visitor will crash if this isn't a [Callable].
+  final AsyncCallable callable;
+
+  SassMixin(this.callable);
+
+  /// @nodoc
+  @internal
+  T accept<T>(ValueVisitor<T> visitor) => visitor.visitMixin(this);
+
+  SassMixin assertMixin([String? name]) => this;
+
+  bool operator ==(Object other) =>
+      other is SassMixin && callable == other.callable;
+
+  int get hashCode => callable.hashCode;
+}