Blame view

node_modules/@babel/helper-member-expression-to-functions/lib/index.js 2.87 KB
ce4c83ff   wxy   初始提交
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = memberExpressionToFunctions;
  
  function t() {
    const data = _interopRequireWildcard(require("@babel/types"));
  
    t = function () {
      return data;
    };
  
    return data;
  }
  
  function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
  
  class AssignmentMemoiser {
    constructor() {
      this._map = new WeakMap();
    }
  
    has(key) {
      return this._map.has(key);
    }
  
    get(key) {
      if (!this.has(key)) return;
  
      const record = this._map.get(key);
  
      const {
        value
      } = record;
      record.count--;
  
      if (record.count === 0) {
        return t().assignmentExpression("=", value, key);
      }
  
      return value;
    }
  
    set(key, value, count) {
      return this._map.set(key, {
        count,
        value
      });
    }
  
  }
  
  const handle = {
    memoise() {},
  
    handle(member) {
      const {
        node,
        parent,
        parentPath
      } = member;
  
      if (parentPath.isUpdateExpression({
        argument: node
      })) {
        const {
          operator,
          prefix
        } = parent;
        this.memoise(member, 2);
        const value = t().binaryExpression(operator[0], t().unaryExpression("+", this.get(member)), t().numericLiteral(1));
  
        if (prefix) {
          parentPath.replaceWith(this.set(member, value));
        } else {
          const {
            scope
          } = member;
          const ref = scope.generateUidIdentifierBasedOnNode(node);
          scope.push({
            id: ref
          });
          value.left = t().assignmentExpression("=", t().cloneNode(ref), value.left);
          parentPath.replaceWith(t().sequenceExpression([this.set(member, value), t().cloneNode(ref)]));
        }
  
        return;
      }
  
      if (parentPath.isAssignmentExpression({
        left: node
      })) {
        const {
          operator,
          right
        } = parent;
        let value = right;
  
        if (operator !== "=") {
          this.memoise(member, 2);
          value = t().binaryExpression(operator.slice(0, -1), this.get(member), value);
        }
  
        parentPath.replaceWith(this.set(member, value));
        return;
      }
  
      if (parentPath.isCallExpression({
        callee: node
      })) {
        const {
          arguments: args
        } = parent;
        parentPath.replaceWith(this.call(member, args));
        return;
      }
  
      member.replaceWith(this.get(member));
    }
  
  };
  
  function memberExpressionToFunctions(path, visitor, state) {
    path.traverse(visitor, Object.assign({}, handle, state, {
      memoiser: new AssignmentMemoiser()
    }));
  }