Revert "Calc functions implementation (#1970)"

This reverts commit e4c8cd6.

Author: nex3

CHANGELOG.md

@@ -1,14 +1,3 @@
-## 1.65.0
-
-* All functions defined in CSS Values and Units 4 are now parsed as calculation
-  objects: `round()`, `mod()`, `rem()`, `sin()`, `cos()`, `tan()`, `asin()`,
-  `acos()`, `atan()`, `atan2()`, `pow()`, `sqrt()`, `hypot()`, `log()`, `exp()`,
-  `abs()`, and `sign()`.
-
-* Deprecate explicitly passing the `%` unit to the global `abs()` function. In
-  future releases, this will emit a CSS abs() function to be resolved by the
-  browser. This deprecation is named `abs-percent`.
-
 ## 1.64.3
 
 ### Dart API

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

@@ -40,10 +40,6 @@ final class CalculationExpression implements Expression {
     }
   }
 
-  /// Returns a `hypot()` calculation expression.
-  CalculationExpression.hypot(Iterable<Expression> arguments, FileSpan span)
-      : this("hypot", arguments, span);
-
   /// Returns a `max()` calculation expression.
   CalculationExpression.max(Iterable<Expression> arguments, this.span)
       : name = "max",
@@ -53,76 +49,11 @@ final class CalculationExpression implements Expression {
     }
   }
 
-  /// Returns a `sqrt()` calculation expression.
-  CalculationExpression.sqrt(Expression argument, FileSpan span)
-      : this("sqrt", [argument], span);
-
-  /// Returns a `sin()` calculation expression.
-  CalculationExpression.sin(Expression argument, FileSpan span)
-      : this("sin", [argument], span);
-
-  /// Returns a `cos()` calculation expression.
-  CalculationExpression.cos(Expression argument, FileSpan span)
-      : this("cos", [argument], span);
-
-  /// Returns a `tan()` calculation expression.
-  CalculationExpression.tan(Expression argument, FileSpan span)
-      : this("tan", [argument], span);
-
-  /// Returns a `asin()` calculation expression.
-  CalculationExpression.asin(Expression argument, FileSpan span)
-      : this("asin", [argument], span);
-
-  /// Returns a `acos()` calculation expression.
-  CalculationExpression.acos(Expression argument, FileSpan span)
-      : this("acos", [argument], span);
-
-  /// Returns a `atan()` calculation expression.
-  CalculationExpression.atan(Expression argument, FileSpan span)
-      : this("atan", [argument], span);
-
-  /// Returns a `abs()` calculation expression.
-  CalculationExpression.abs(Expression argument, FileSpan span)
-      : this("abs", [argument], span);
-
-  /// Returns a `sign()` calculation expression.
-  CalculationExpression.sign(Expression argument, FileSpan span)
-      : this("sign", [argument], span);
-
-  /// Returns a `exp()` calculation expression.
-  CalculationExpression.exp(Expression argument, FileSpan span)
-      : this("exp", [argument], span);
-
   /// Returns a `clamp()` calculation expression.
   CalculationExpression.clamp(
       Expression min, Expression value, Expression max, FileSpan span)
       : this("clamp", [min, max, value], span);
 
-  /// Returns a `pow()` calculation expression.
-  CalculationExpression.pow(Expression base, Expression exponent, FileSpan span)
-      : this("pow", [base, exponent], span);
-
-  /// Returns a `log()` calculation expression.
-  CalculationExpression.log(Expression number, Expression base, FileSpan span)
-      : this("log", [number, base], span);
-
-  /// Returns a `round()` calculation expression.
-  CalculationExpression.round(
-      Expression strategy, Expression number, Expression step, FileSpan span)
-      : this("round", [strategy, number, step], span);
-
-  /// Returns a `atan2()` calculation expression.
-  CalculationExpression.atan2(Expression y, Expression x, FileSpan span)
-      : this("atan2", [y, x], span);
-
-  /// Returns a `mod()` calculation expression.
-  CalculationExpression.mod(Expression y, Expression x, FileSpan span)
-      : this("mod", [y, x], span);
-
-  /// Returns a `rem()` calculation expression.
-  CalculationExpression.rem(Expression y, Expression x, FileSpan span)
-      : this("rem", [y, x], span);
-
   /// Returns a calculation expression with the given name and arguments.
   ///
   /// Unlike the other constructors, this doesn't verify that the arguments are

lib/src/deprecation.dart

@@ -55,11 +55,6 @@ enum Deprecation {
       deprecatedIn: '1.56.0',
       description: 'Passing invalid units to built-in functions.'),
 
-  /// Deprecation for passing percentages to the Sass abs() function.
-  absPercent('abs-percent',
-      deprecatedIn: '1.64.0',
-      description: 'Passing percentages to the Sass abs() function.'),
-
   duplicateVariableFlags('duplicate-var-flags',
       deprecatedIn: '1.62.0',
       description:

lib/src/functions/math.dart

@@ -12,7 +12,6 @@ import '../deprecation.dart';
 import '../evaluation_context.dart';
 import '../exception.dart';
 import '../module/built_in.dart';
-import '../util/number.dart';
 import '../value.dart';
 
 /// The global definitions of Sass math functions.
@@ -133,32 +132,87 @@ final _log = _function("log", r"$number, $base: null", (arguments) {
 final _pow = _function("pow", r"$base, $exponent", (arguments) {
   var base = arguments[0].assertNumber("base");
   var exponent = arguments[1].assertNumber("exponent");
-  return pow(base, exponent);
+  if (base.hasUnits) {
+    throw SassScriptException("\$base: Expected $base to have no units.");
+  } else if (exponent.hasUnits) {
+    throw SassScriptException(
+        "\$exponent: Expected $exponent to have no units.");
+  } else {
+    return SassNumber(math.pow(base.value, exponent.value));
+  }
 });
 
-final _sqrt = _singleArgumentMathFunc("sqrt", sqrt);
+final _sqrt = _function("sqrt", r"$number", (arguments) {
+  var number = arguments[0].assertNumber("number");
+  if (number.hasUnits) {
+    throw SassScriptException("\$number: Expected $number to have no units.");
+  } else {
+    return SassNumber(math.sqrt(number.value));
+  }
+});
 
 ///
 /// Trigonometric functions
 ///
 
-final _acos = _singleArgumentMathFunc("acos", acos);
+final _acos = _function("acos", r"$number", (arguments) {
+  var number = arguments[0].assertNumber("number");
+  if (number.hasUnits) {
+    throw SassScriptException("\$number: Expected $number to have no units.");
+  } else {
+    return SassNumber.withUnits(math.acos(number.value) * 180 / math.pi,
+        numeratorUnits: ['deg']);
+  }
+});
 
-final _asin = _singleArgumentMathFunc("asin", asin);
+final _asin = _function("asin", r"$number", (arguments) {
+  var number = arguments[0].assertNumber("number");
+  if (number.hasUnits) {
+    throw SassScriptException("\$number: Expected $number to have no units.");
+  } else {
+    return SassNumber.withUnits(math.asin(number.value) * 180 / math.pi,
+        numeratorUnits: ['deg']);
+  }
+});
 
-final _atan = _singleArgumentMathFunc("atan", atan);
+final _atan = _function("atan", r"$number", (arguments) {
+  var number = arguments[0].assertNumber("number");
+  if (number.hasUnits) {
+    throw SassScriptException("\$number: Expected $number to have no units.");
+  } else {
+    return SassNumber.withUnits(math.atan(number.value) * 180 / math.pi,
+        numeratorUnits: ['deg']);
+  }
+});
 
 final _atan2 = _function("atan2", r"$y, $x", (arguments) {
   var y = arguments[0].assertNumber("y");
   var x = arguments[1].assertNumber("x");
-  return atan2(y, x);
+  return SassNumber.withUnits(
+      math.atan2(y.value, x.convertValueToMatch(y, 'x', 'y')) * 180 / math.pi,
+      numeratorUnits: ['deg']);
 });
 
-final _cos = _singleArgumentMathFunc("cos", cos);
-
-final _sin = _singleArgumentMathFunc("sin", sin);
-
-final _tan = _singleArgumentMathFunc("tan", tan);
+final _cos = _function(
+    "cos",
+    r"$number",
+    (arguments) => SassNumber(math.cos(arguments[0]
+        .assertNumber("number")
+        .coerceValueToUnit("rad", "number"))));
+
+final _sin = _function(
+    "sin",
+    r"$number",
+    (arguments) => SassNumber(math.sin(arguments[0]
+        .assertNumber("number")
+        .coerceValueToUnit("rad", "number"))));
+
+final _tan = _function(
+    "tan",
+    r"$number",
+    (arguments) => SassNumber(math.tan(arguments[0]
+        .assertNumber("number")
+        .coerceValueToUnit("rad", "number"))));
 
 ///
 /// Unit functions
@@ -234,16 +288,6 @@ final _div = _function("div", r"$number1, $number2", (arguments) {
 /// Helpers
 ///
 
-/// Returns a [Callable] named [name] that calls a single argument
-/// math function.
-BuiltInCallable _singleArgumentMathFunc(
-    String name, SassNumber mathFunc(SassNumber value)) {
-  return _function(name, r"$number", (arguments) {
-    var number = arguments[0].assertNumber("number");
-    return mathFunc(number);
-  });
-}
-
 /// Returns a [Callable] named [name] that transforms a number's value
 /// using [transform] and preserves its units.
 BuiltInCallable _numberFunction(String name, double transform(double value)) {

lib/src/js/value/calculation.dart

@@ -93,7 +93,7 @@ final JSClass calculationOperationClass = () {
     _assertCalculationValue(left);
     _assertCalculationValue(right);
     return SassCalculation.operateInternal(operator, left, right,
-        inLegacySassFunction: false, simplify: false);
+        inMinMax: false, simplify: false);
   });
 
   jsClass.defineMethods({
@@ -109,7 +109,7 @@ final JSClass calculationOperationClass = () {
 
   getJSClass(SassCalculation.operateInternal(
           CalculationOperator.plus, SassNumber(1), SassNumber(1),
-          inLegacySassFunction: false, simplify: false))
+          inMinMax: false, simplify: false))
       .injectSuperclass(jsClass);
   return jsClass;
 }();

lib/src/parse/stylesheet.dart

@@ -2065,8 +2065,7 @@ abstract class StylesheetParser extends Parser {
   /// produces a potentially slash-separated number.
   bool _isSlashOperand(Expression expression) =>
       expression is NumberExpression ||
-      (expression is CalculationExpression &&
-          !{'min', 'max', 'round', 'abs'}.contains(expression.name)) ||
+      expression is CalculationExpression ||
       (expression is BinaryOperationExpression && expression.allowsSlash);
 
   /// Consumes an expression that doesn't contain any top-level whitespace.
@@ -2653,64 +2652,32 @@ abstract class StylesheetParser extends Parser {
     assert(scanner.peekChar() == $lparen);
     switch (name) {
       case "calc":
-      case "sqrt":
-      case "sin":
-      case "cos":
-      case "tan":
-      case "asin":
-      case "acos":
-      case "atan":
-      case "exp":
-      case "sign":
         var arguments = _calculationArguments(1);
         return CalculationExpression(name, arguments, scanner.spanFrom(start));
 
-      case "abs":
-        return _tryArgumentsCalculation(name, start, 1);
-
-      case "hypot":
-        var arguments = _calculationArguments();
-        return CalculationExpression(name, arguments, scanner.spanFrom(start));
-
       case "min" || "max":
         // min() and max() are parsed as calculations if possible, and otherwise
         // are parsed as normal Sass functions.
-        return _tryArgumentsCalculation(name, start, null);
-
-      case "pow":
-      case "log":
-      case "atan2":
-      case "mod":
-      case "rem":
-        var arguments = _calculationArguments(2);
+        var beforeArguments = scanner.state;
+        List<Expression> arguments;
+        try {
+          arguments = _calculationArguments();
+        } on FormatException catch (_) {
+          scanner.state = beforeArguments;
+          return null;
+        }
+
         return CalculationExpression(name, arguments, scanner.spanFrom(start));
 
       case "clamp":
         var arguments = _calculationArguments(3);
         return CalculationExpression(name, arguments, scanner.spanFrom(start));
 
-      case "round":
-        return _tryArgumentsCalculation(name, start, 3);
-
       case _:
         return null;
     }
   }
 
-  // Returns a CalculationExpression if the function can be parsed as a calculation,
-  // otherwise, returns null and the function is parsed as a normal Sass function.
-  CalculationExpression? _tryArgumentsCalculation(
-      String name, LineScannerState start, int? maxArgs) {
-    var beforeArguments = scanner.state;
-    try {
-      var arguments = _calculationArguments(maxArgs);
-      return CalculationExpression(name, arguments, scanner.spanFrom(start));
-    } on FormatException catch (_) {
-      scanner.state = beforeArguments;
-      return null;
-    }
-  }
-
   /// Consumes and returns arguments for a calculation expression, including the
   /// opening and closing parentheses.
   ///