Add sass-parser support for @return and @mixin

CHANGELOG.md

@@ -1,3 +1,7 @@
+## 1.82.1-dev
+
+* No user-visible changes.
+
 ## 1.82.0
 
 ### Command-Line Interface

lib/src/js/parser.dart

@@ -93,7 +93,8 @@ void _updateAstPrototypes() {
       .defineGetter('arguments', (ArgumentDeclaration self) => self.arguments);
   var function = FunctionRule('a', arguments, [], bogusSpan);
   getJSClass(function)
-      .defineGetter('arguments', (FunctionRule self) => self.arguments);
+      .superclass
+      .defineGetter('arguments', (CallableDeclaration self) => self.arguments);
 
   _addSupportsConditionToInterpolation();
 

pkg/sass-parser/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.4.8-dev
+
+Add support for parsing the `@mixin` rule.
+
+Add support for parsing the `@return` rule.
+
 ## 0.4.7
 
 * No user-visible changes.

pkg/sass-parser/lib/index.ts

@@ -104,6 +104,16 @@ export {
   GenericAtRuleProps,
   GenericAtRuleRaws,
 } from './src/statement/generic-at-rule';
+export {
+  MixinRule,
+  MixinRuleProps,
+  MixinRuleRaws,
+} from './src/statement/mixin-rule';
+export {
+  ReturnRule,
+  ReturnRuleProps,
+  ReturnRuleRaws,
+} from './src/statement/return-rule';
 export {Root, RootProps, RootRaws} from './src/statement/root';
 export {Rule, RuleProps, RuleRaws} from './src/statement/rule';
 export {

pkg/sass-parser/lib/src/sass-internal.ts

@@ -147,6 +147,15 @@ declare namespace SassInternal {
     readonly query: Interpolation;
   }
 
+  class MixinRule extends ParentStatement<Statement[]> {
+    readonly name: string;
+    readonly arguments: ArgumentDeclaration;
+  }
+
+  class ReturnRule extends Statement {
+    readonly expression: Expression;
+  }
+
   class SilentComment extends Statement {
     readonly text: string;
   }
@@ -285,6 +294,8 @@ export type ForwardRule = SassInternal.ForwardRule;
 export type FunctionRule = SassInternal.FunctionRule;
 export type LoudComment = SassInternal.LoudComment;
 export type MediaRule = SassInternal.MediaRule;
+export type MixinRule = SassInternal.MixinRule;
+export type ReturnRule = SassInternal.ReturnRule;
 export type SilentComment = SassInternal.SilentComment;
 export type Stylesheet = SassInternal.Stylesheet;
 export type StyleRule = SassInternal.StyleRule;
@@ -315,6 +326,8 @@ export interface StatementVisitorObject<T> {
   visitFunctionRule(node: FunctionRule): T;
   visitLoudComment(node: LoudComment): T;
   visitMediaRule(node: MediaRule): T;
+  visitMixinRule(node: MixinRule): T;
+  visitReturnRule(node: ReturnRule): T;
   visitSilentComment(node: SilentComment): T;
   visitStyleRule(node: StyleRule): T;
   visitSupportsRule(node: SupportsRule): T;

pkg/sass-parser/lib/src/statement/__snapshots__/mixin-rule.test.ts.snap

@@ -0,0 +1,21 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`a @mixin rule toJSON 1`] = `
+{
+  "inputs": [
+    {
+      "css": "@mixin foo($bar) {}",
+      "hasBOM": false,
+      "id": "<input css _____>",
+    },
+  ],
+  "mixinName": "foo",
+  "name": "mixin",
+  "nodes": [],
+  "parameters": <($bar)>,
+  "raws": {},
+  "sassType": "mixin-rule",
+  "source": <1:1-1:20 in 0>,
+  "type": "atrule",
+}
+`;

pkg/sass-parser/lib/src/statement/__snapshots__/return-rule.test.ts.snap

@@ -0,0 +1,20 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`a @return rule toJSON 1`] = `
+{
+  "inputs": [
+    {
+      "css": "@function x() {@return foo}",
+      "hasBOM": false,
+      "id": "<input css _____>",
+    },
+  ],
+  "name": "return",
+  "params": "foo",
+  "raws": {},
+  "returnExpression": <foo>,
+  "sassType": "return-rule",
+  "source": <1:16-1:27 in 0>,
+  "type": "atrule",
+}
+`;

pkg/sass-parser/lib/src/statement/function-rule.test.ts

@@ -2,7 +2,7 @@
 // MIT-style license that can be found in the LICENSE file or at
 // https://opensource.org/licenses/MIT.
 
-import {FunctionRule, ParameterList, sass, scss} from '../..';
+import {FunctionRule, ParameterList, ReturnRule, sass, scss} from '../..';
 import * as utils from '../../../test/utils';
 
 describe('a @function rule', () => {
@@ -49,60 +49,67 @@ describe('a @function rule', () => {
     );
   });
 
-  // TODO(nweiz): Enable this when we parse ReturnRule.
-  //
-  // describe('with a child', () => {
-  //   function describeNode(description: string, create: () => FunctionRule): void {
-  //     describe(description, () => {
-  //       beforeEach(() => void (node = create()));
-  //
-  //       it('has a name', () => expect(node.name.toString()).toBe('function'));
-  //
-  //       it('has a function name', () => expect(node.functionName.toString()).toBe('foo'));
-  //
-  //       it('has a parameter', () =>
-  //         expect(node.parameters.nodes[0].name).toEqual('bar'));
-  //
-  //       it('has matching params', () =>
-  //         expect(node.params).toBe('foo($bar)'));
-  //
-  //       it('has a child node', () => {
-  //         expect(node.nodes).toHaveLength(1);
-  //         expect(node.nodes[0]).toBeInstanceOf(ReturnRule);
-  //         expect(node.nodes[0]).toHaveStringExpression('returnExpression', 'baz');
-  //       });
-  //     });
-  //   }
-  //
-  //   describeNode(
-  //     'parsed as SCSS',
-  //     () => scss.parse('@function foo($bar) {@return "baz"}').nodes[0] as FunctionRule,
-  //   );
-  //
-  //   describeNode(
-  //     'parsed as Sass',
-  //     () =>
-  //       sass.parse('@function foo($bar)\n  @return "baz"').nodes[0] as FunctionRule,
-  //   );
-  //
-  //   describeNode(
-  //     'constructed manually',
-  //     () =>
-  //       new FunctionRule({
-  //         name: 'foo',
-  //         parameters: ['bar'],
-  //         nodes: [{returnExpression: 'child'}],
-  //       }),
-  //   );
-  //
-  //   describeNode('constructed from ChildProps', () =>
-  //     utils.fromChildProps({
-  //         name: 'foo',
-  //         parameters: ['bar'],
-  //         nodes: [{returnExpression: 'child'}],
-  //       }),
-  //   );
-  // });
+  describe('with a child', () => {
+    function describeNode(
+      description: string,
+      create: () => FunctionRule,
+    ): void {
+      describe(description, () => {
+        beforeEach(() => void (node = create()));
+
+        it('has a name', () => expect(node.name.toString()).toBe('function'));
+
+        it('has a function name', () =>
+          expect(node.functionName.toString()).toBe('foo'));
+
+        it('has a parameter', () =>
+          expect(node.parameters.nodes[0].name).toEqual('bar'));
+
+        it('has matching params', () => expect(node.params).toBe('foo($bar)'));
+
+        it('has a child node', () => {
+          expect(node.nodes).toHaveLength(1);
+          expect(node.nodes[0]).toBeInstanceOf(ReturnRule);
+          expect(node.nodes[0]).toHaveStringExpression(
+            'returnExpression',
+            'baz',
+          );
+        });
+      });
+    }
+
+    describeNode(
+      'parsed as SCSS',
+      () =>
+        scss.parse('@function foo($bar) {@return "baz"}')
+          .nodes[0] as FunctionRule,
+    );
+
+    describeNode(
+      'parsed as Sass',
+      () =>
+        sass.parse('@function foo($bar)\n  @return "baz"')
+          .nodes[0] as FunctionRule,
+    );
+
+    describeNode(
+      'constructed manually',
+      () =>
+        new FunctionRule({
+          functionName: 'foo',
+          parameters: ['bar'],
+          nodes: [{returnExpression: {text: 'baz'}}],
+        }),
+    );
+
+    describeNode('constructed from ChildProps', () =>
+      utils.fromChildProps({
+        functionName: 'foo',
+        parameters: ['bar'],
+        nodes: [{returnExpression: {text: 'baz'}}],
+      }),
+    );
+  });
 
   describe('throws an error when assigned a new', () => {
     beforeEach(

pkg/sass-parser/lib/src/statement/index.ts

@@ -18,6 +18,8 @@ import {ErrorRule, ErrorRuleProps} from './error-rule';
 import {ForRule, ForRuleProps} from './for-rule';
 import {ForwardRule, ForwardRuleProps} from './forward-rule';
 import {FunctionRule, FunctionRuleProps} from './function-rule';
+import {MixinRule, MixinRuleProps} from './mixin-rule';
+import {ReturnRule, ReturnRuleProps} from './return-rule';
 import {Root} from './root';
 import {Rule, RuleProps} from './rule';
 import {UseRule, UseRuleProps} from './use-rule';
@@ -55,12 +57,14 @@ export type StatementType =
   | 'comment'
   | 'debug-rule'
   | 'each-rule'
+  | 'error-rule'
   | 'for-rule'
   | 'forward-rule'
   | 'function-rule'
-  | 'error-rule'
-  | 'use-rule'
+  | 'mixin-rule'
+  | 'return-rule'
   | 'sass-comment'
+  | 'use-rule'
   | 'variable-declaration'
   | 'warn-rule'
   | 'while-rule';
@@ -78,6 +82,8 @@ export type AtRule =
   | ForwardRule
   | FunctionRule
   | GenericAtRule
+  | MixinRule
+  | ReturnRule
   | UseRule
   | WarnRule
   | WhileRule;
@@ -115,6 +121,8 @@ export type ChildProps =
   | ForwardRuleProps
   | FunctionRuleProps
   | GenericAtRuleProps
+  | MixinRuleProps
+  | ReturnRuleProps
   | RuleProps
   | SassCommentChildProps
   | UseRuleProps
@@ -195,6 +203,8 @@ const visitor = sassInternal.createStatementVisitor<Statement>({
     appendInternalChildren(rule, inner.children);
     return rule;
   },
+  visitMixinRule: inner => new MixinRule(undefined, inner),
+  visitReturnRule: inner => new ReturnRule(undefined, inner),
   visitSilentComment: inner => new SassComment(undefined, inner),
   visitStyleRule: inner => new Rule(undefined, inner),
   visitSupportsRule: inner => {
@@ -319,18 +329,22 @@ export function normalize(
       result.push(new DebugRule(node));
     } else if ('eachExpression' in node) {
       result.push(new EachRule(node));
+    } else if ('errorExpression' in node) {
+      result.push(new ErrorRule(node));
     } else if ('fromExpression' in node) {
       result.push(new ForRule(node));
     } else if ('forwardUrl' in node) {
       result.push(new ForwardRule(node));
     } else if ('functionName' in node) {
       result.push(new FunctionRule(node));
-    } else if ('errorExpression' in node) {
-      result.push(new ErrorRule(node));
-    } else if ('text' in node || 'textInterpolation' in node) {
-      result.push(new CssComment(node as CssCommentProps));
+    } else if ('mixinName' in node) {
+      result.push(new MixinRule(node));
+    } else if ('returnExpression' in node) {
+      result.push(new ReturnRule(node));
     } else if ('silentText' in node) {
       result.push(new SassComment(node));
+    } else if ('text' in node || 'textInterpolation' in node) {
+      result.push(new CssComment(node as CssCommentProps));
     } else if ('useUrl' in node) {
       result.push(new UseRule(node));
     } else if ('variableName' in node) {