推送

WXL

3 天以前 3bd962a6d7f61239c020e2dbbeb7341e5b842dd1

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
130
131
132
133
134
135
/*
    MIT License http://www.opensource.org/licenses/mit-license.php
    Author Tobias Koppers @sokra
*/
 
"use strict";
 
const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
const ConstDependency = require("../dependencies/ConstDependency");
const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 
/** @typedef {import("estree").Expression} Expression */
/** @typedef {import("estree").SourceLocation} SourceLocation */
/** @typedef {import("./JavascriptParser")} JavascriptParser */
/** @typedef {import("./JavascriptParser").Range} Range */
/** @typedef {import("./BasicEvaluatedExpression").GetMembers} GetMembers */
 
module.exports.approve = () => true;
 
/**
 * Returns plugin function.
 * @param {boolean} value the boolean value
 * @returns {(expression: Expression) => BasicEvaluatedExpression} plugin function
 */
module.exports.evaluateToBoolean = (value) =>
    function booleanExpression(expr) {
        return new BasicEvaluatedExpression()
            .setBoolean(value)
            .setRange(/** @type {Range} */ (expr.range));
    };
 
/**
 * Returns callback.
 * @param {string} identifier identifier
 * @param {string} rootInfo rootInfo
 * @param {GetMembers} getMembers getMembers
 * @param {boolean | null=} truthy is truthy, null if nullish
 * @returns {(expression: Expression) => BasicEvaluatedExpression} callback
 */
module.exports.evaluateToIdentifier = (
    identifier,
    rootInfo,
    getMembers,
    truthy
) =>
    function identifierExpression(expr) {
        const evaluatedExpression = new BasicEvaluatedExpression()
            .setIdentifier(identifier, rootInfo, getMembers)
            .setSideEffects(false)
            .setRange(/** @type {Range} */ (expr.range));
        switch (truthy) {
            case true:
                evaluatedExpression.setTruthy();
                break;
            case null:
                evaluatedExpression.setNullish(true);
                break;
            case false:
                evaluatedExpression.setFalsy();
                break;
        }
 
        return evaluatedExpression;
    };
 
/**
 * Returns plugin function.
 * @param {number} value the number value
 * @returns {(expression: Expression) => BasicEvaluatedExpression} plugin function
 */
module.exports.evaluateToNumber = (value) =>
    function stringExpression(expr) {
        return new BasicEvaluatedExpression()
            .setNumber(value)
            .setRange(/** @type {Range} */ (expr.range));
    };
 
/**
 * Returns plugin function.
 * @param {string} value the string value
 * @returns {(expression: Expression) => BasicEvaluatedExpression} plugin function
 */
module.exports.evaluateToString = (value) =>
    function stringExpression(expr) {
        return new BasicEvaluatedExpression()
            .setString(value)
            .setRange(/** @type {Range} */ (expr.range));
    };
 
/**
 * Returns callback to handle unsupported expression.
 * @param {JavascriptParser} parser the parser
 * @param {string} message the message
 * @returns {(expression: Expression) => boolean | undefined} callback to handle unsupported expression
 */
module.exports.expressionIsUnsupported = (parser, message) =>
    function unsupportedExpression(expr) {
        const dep = new ConstDependency(
            "(void 0)",
            /** @type {Range} */ (expr.range),
            null
        );
        dep.loc = /** @type {SourceLocation} */ (expr.loc);
        parser.state.module.addPresentationalDependency(dep);
        if (!parser.state.module) return;
        parser.state.module.addWarning(
            new UnsupportedFeatureWarning(
                message,
                /** @type {SourceLocation} */ (expr.loc)
            )
        );
        return true;
    };
 
module.exports.skipTraversal = () => true;
 
/**
 * Returns plugin function.
 * @param {JavascriptParser} parser the parser
 * @param {string} value the const value
 * @param {(string[] | null)=} runtimeRequirements runtime requirements
 * @returns {(expression: Expression) => true} plugin function
 */
module.exports.toConstantDependency = (parser, value, runtimeRequirements) =>
    function constDependency(expr) {
        const dep = new ConstDependency(
            value,
            /** @type {Range} */
            (expr.range),
            runtimeRequirements
        );
        dep.loc = /** @type {SourceLocation} */ (expr.loc);
        parser.state.module.addPresentationalDependency(dep);
        return true;
    };