mirror of
https://github.com/google/blockly.git
synced 2026-01-04 15:40:08 +01:00
a6208d78b7
Fixes #2156. In PRs #7602, #7616, #7646, #7647 and #7654 the @protected access modifier on scrub_ on the CodeGenerator subclasses was not transcribed to the new typescript signature. I was going to re-add it, but this breaks some of the procedure block generator functions which rely on it, and then @BeksOmega pointed out that this might be one of the CodeGenerator API functions which we had already decided should be public—and lo and behold I found #2156. Per discussion amongst team, I am not renaming it to scrub at this time.
347 lines
11 KiB
TypeScript
347 lines
11 KiB
TypeScript
/**
|
|
* @license
|
|
* Copyright 2012 Google LLC
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
/**
|
|
* @file JavaScript code generator class, including helper methods for
|
|
* generating JavaScript for blocks.
|
|
*/
|
|
|
|
// Former goog.module ID: Blockly.JavaScript
|
|
|
|
import * as Variables from '../../core/variables.js';
|
|
import * as stringUtils from '../../core/utils/string.js';
|
|
import type {Block} from '../../core/block.js';
|
|
import {CodeGenerator} from '../../core/generator.js';
|
|
import {Names, NameType} from '../../core/names.js';
|
|
import type {Workspace} from '../../core/workspace.js';
|
|
import {inputTypes} from '../../core/inputs/input_types.js';
|
|
|
|
/**
|
|
* Order of operation ENUMs.
|
|
* https://developer.mozilla.org/en/JavaScript/Reference/Operators/Operator_Precedence
|
|
*/
|
|
// prettier-ignore
|
|
export enum Order {
|
|
ATOMIC = 0, // 0 "" ...
|
|
NEW = 1.1, // new
|
|
MEMBER = 1.2, // . []
|
|
FUNCTION_CALL = 2, // ()
|
|
INCREMENT = 3, // ++
|
|
DECREMENT = 3, // --
|
|
BITWISE_NOT = 4.1, // ~
|
|
UNARY_PLUS = 4.2, // +
|
|
UNARY_NEGATION = 4.3, // -
|
|
LOGICAL_NOT = 4.4, // !
|
|
TYPEOF = 4.5, // typeof
|
|
VOID = 4.6, // void
|
|
DELETE = 4.7, // delete
|
|
AWAIT = 4.8, // await
|
|
EXPONENTIATION = 5.0, // **
|
|
MULTIPLICATION = 5.1, // *
|
|
DIVISION = 5.2, // /
|
|
MODULUS = 5.3, // %
|
|
SUBTRACTION = 6.1, // -
|
|
ADDITION = 6.2, // +
|
|
BITWISE_SHIFT = 7, // << >> >>>
|
|
RELATIONAL = 8, // < <= > >=
|
|
IN = 8, // in
|
|
INSTANCEOF = 8, // instanceof
|
|
EQUALITY = 9, // == != === !==
|
|
BITWISE_AND = 10, // &
|
|
BITWISE_XOR = 11, // ^
|
|
BITWISE_OR = 12, // |
|
|
LOGICAL_AND = 13, // &&
|
|
LOGICAL_OR = 14, // ||
|
|
CONDITIONAL = 15, // ?:
|
|
ASSIGNMENT = 16, // = += -= **= *= /= %= <<= >>= ...
|
|
YIELD = 17, // yield
|
|
COMMA = 18, // ,
|
|
NONE = 99, // (...)
|
|
}
|
|
|
|
/**
|
|
* JavaScript code generator class.
|
|
*/
|
|
export class JavascriptGenerator extends CodeGenerator {
|
|
/** List of outer-inner pairings that do NOT require parentheses. */
|
|
ORDER_OVERRIDES: [Order, Order][] = [
|
|
// (foo()).bar -> foo().bar
|
|
// (foo())[0] -> foo()[0]
|
|
[Order.FUNCTION_CALL, Order.MEMBER],
|
|
// (foo())() -> foo()()
|
|
[Order.FUNCTION_CALL, Order.FUNCTION_CALL],
|
|
// (foo.bar).baz -> foo.bar.baz
|
|
// (foo.bar)[0] -> foo.bar[0]
|
|
// (foo[0]).bar -> foo[0].bar
|
|
// (foo[0])[1] -> foo[0][1]
|
|
[Order.MEMBER, Order.MEMBER],
|
|
// (foo.bar)() -> foo.bar()
|
|
// (foo[0])() -> foo[0]()
|
|
[Order.MEMBER, Order.FUNCTION_CALL],
|
|
|
|
// !(!foo) -> !!foo
|
|
[Order.LOGICAL_NOT, Order.LOGICAL_NOT],
|
|
// a * (b * c) -> a * b * c
|
|
[Order.MULTIPLICATION, Order.MULTIPLICATION],
|
|
// a + (b + c) -> a + b + c
|
|
[Order.ADDITION, Order.ADDITION],
|
|
// a && (b && c) -> a && b && c
|
|
[Order.LOGICAL_AND, Order.LOGICAL_AND],
|
|
// a || (b || c) -> a || b || c
|
|
[Order.LOGICAL_OR, Order.LOGICAL_OR],
|
|
];
|
|
|
|
/** @param name Name of the language the generator is for. */
|
|
constructor(name = 'JavaScript') {
|
|
super(name);
|
|
this.isInitialized = false;
|
|
|
|
// Copy Order values onto instance for backwards compatibility
|
|
// while ensuring they are not part of the publically-advertised
|
|
// API.
|
|
//
|
|
// TODO(#7085): deprecate these in due course. (Could initially
|
|
// replace data properties with get accessors that call
|
|
// deprecate.warn().)
|
|
for (const key in Order) {
|
|
// Must assign Order[key] to a temporary to get the type guard to work;
|
|
// see https://github.com/microsoft/TypeScript/issues/10530.
|
|
const value = Order[key];
|
|
// Skip reverse-lookup entries in the enum. Due to
|
|
// https://github.com/microsoft/TypeScript/issues/55713 this (as
|
|
// of TypeScript 5.5.2) actually narrows the type of value to
|
|
// never - but that still allows the following assignment to
|
|
// succeed.
|
|
if (typeof value === 'string') continue;
|
|
(this as unknown as Record<string, Order>)['ORDER_' + key] = value;
|
|
}
|
|
|
|
// List of illegal variable names. This is not intended to be a
|
|
// security feature. Blockly is 100% client-side, so bypassing
|
|
// this list is trivial. This is intended to prevent users from
|
|
// accidentally clobbering a built-in object or function.
|
|
//
|
|
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Keywords
|
|
this.addReservedWords(
|
|
'break,case,catch,class,const,continue,debugger,default,delete,do,' +
|
|
'else,export,extends,finally,for,function,if,import,in,instanceof,' +
|
|
'new,return,super,switch,this,throw,try,typeof,var,void,' +
|
|
'while,with,yield,' +
|
|
'enum,' +
|
|
'implements,interface,let,package,private,protected,public,static,' +
|
|
'await,' +
|
|
'null,true,false,' +
|
|
// Magic variable.
|
|
'arguments,' +
|
|
// Everything in the current environment (835 items in Chrome,
|
|
// 104 in Node).
|
|
Object.getOwnPropertyNames(globalThis).join(','),
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Initialise the database of variable names.
|
|
*
|
|
* @param workspace Workspace to generate code from.
|
|
*/
|
|
init(workspace: Workspace) {
|
|
super.init(workspace);
|
|
|
|
if (!this.nameDB_) {
|
|
this.nameDB_ = new Names(this.RESERVED_WORDS_);
|
|
} else {
|
|
this.nameDB_.reset();
|
|
}
|
|
|
|
this.nameDB_.setVariableMap(workspace.getVariableMap());
|
|
this.nameDB_.populateVariables(workspace);
|
|
this.nameDB_.populateProcedures(workspace);
|
|
|
|
const defvars = [];
|
|
// Add developer variables (not created or named by the user).
|
|
const devVarList = Variables.allDeveloperVariables(workspace);
|
|
for (let i = 0; i < devVarList.length; i++) {
|
|
defvars.push(
|
|
this.nameDB_.getName(devVarList[i], NameType.DEVELOPER_VARIABLE),
|
|
);
|
|
}
|
|
|
|
// Add user variables, but only ones that are being used.
|
|
const variables = Variables.allUsedVarModels(workspace);
|
|
for (let i = 0; i < variables.length; i++) {
|
|
defvars.push(
|
|
this.nameDB_.getName(variables[i].getId(), NameType.VARIABLE),
|
|
);
|
|
}
|
|
|
|
// Declare all of the variables.
|
|
if (defvars.length) {
|
|
this.definitions_['variables'] = 'var ' + defvars.join(', ') + ';';
|
|
}
|
|
this.isInitialized = true;
|
|
}
|
|
|
|
/**
|
|
* Prepend the generated code with the variable definitions.
|
|
*
|
|
* @param code Generated code.
|
|
* @returns Completed code.
|
|
*/
|
|
finish(code: string): string {
|
|
// Convert the definitions dictionary into a list.
|
|
const definitions = Object.values(this.definitions_);
|
|
// Call Blockly.CodeGenerator's finish.
|
|
super.finish(code);
|
|
this.isInitialized = false;
|
|
|
|
this.nameDB_!.reset();
|
|
return definitions.join('\n\n') + '\n\n\n' + code;
|
|
}
|
|
|
|
/**
|
|
* Naked values are top-level blocks with outputs that aren't plugged into
|
|
* anything. A trailing semicolon is needed to make this legal.
|
|
*
|
|
* @param line Line of generated code.
|
|
* @returns Legal line of code.
|
|
*/
|
|
scrubNakedValue(line: string): string {
|
|
return line + ';\n';
|
|
}
|
|
|
|
/**
|
|
* Encode a string as a properly escaped JavaScript string, complete with
|
|
* quotes.
|
|
*
|
|
* @param string Text to encode.
|
|
* @returns JavaScript string.
|
|
*/
|
|
quote_(string: string): string {
|
|
// Can't use goog.string.quote since Google's style guide recommends
|
|
// JS string literals use single quotes.
|
|
string = string
|
|
.replace(/\\/g, '\\\\')
|
|
.replace(/\n/g, '\\\n')
|
|
.replace(/'/g, "\\'");
|
|
return "'" + string + "'";
|
|
}
|
|
|
|
/**
|
|
* Encode a string as a properly escaped multiline JavaScript string, complete
|
|
* with quotes.
|
|
* @param string Text to encode.
|
|
* @returns JavaScript string.
|
|
*/
|
|
multiline_quote_(string: string): string {
|
|
// Can't use goog.string.quote since Google's style guide recommends
|
|
// JS string literals use single quotes.
|
|
const lines = string.split(/\n/g).map(this.quote_);
|
|
return lines.join(" + '\\n' +\n");
|
|
}
|
|
|
|
/**
|
|
* Common tasks for generating JavaScript from blocks.
|
|
* Handles comments for the specified block and any connected value blocks.
|
|
* Calls any statements following this block.
|
|
*
|
|
* @param block The current block.
|
|
* @param code The JavaScript code created for this block.
|
|
* @param thisOnly True to generate code for only this statement.
|
|
* @returns JavaScript code with comments and subsequent blocks added.
|
|
*/
|
|
scrub_(block: Block, code: string, thisOnly = false): string {
|
|
let commentCode = '';
|
|
// Only collect comments for blocks that aren't inline.
|
|
if (!block.outputConnection || !block.outputConnection.targetConnection) {
|
|
// Collect comment for this block.
|
|
let comment = block.getCommentText();
|
|
if (comment) {
|
|
comment = stringUtils.wrap(comment, this.COMMENT_WRAP - 3);
|
|
commentCode += this.prefixLines(comment + '\n', '// ');
|
|
}
|
|
// Collect comments for all value arguments.
|
|
// Don't collect comments for nested statements.
|
|
for (let i = 0; i < block.inputList.length; i++) {
|
|
if (block.inputList[i].type === inputTypes.VALUE) {
|
|
const childBlock = block.inputList[i].connection!.targetBlock();
|
|
if (childBlock) {
|
|
comment = this.allNestedComments(childBlock);
|
|
if (comment) {
|
|
commentCode += this.prefixLines(comment, '// ');
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const nextBlock =
|
|
block.nextConnection && block.nextConnection.targetBlock();
|
|
const nextCode = thisOnly ? '' : this.blockToCode(nextBlock);
|
|
return commentCode + code + nextCode;
|
|
}
|
|
|
|
/**
|
|
* Generate code representing the specified value input, adjusted to take into
|
|
* account indexing (zero- or one-based) and optionally by a specified delta
|
|
* and/or by negation.
|
|
*
|
|
* @param block The block.
|
|
* @param atId The ID of the input block to get (and adjust) the value of.
|
|
* @param delta Value to add.
|
|
* @param negate Whether to negate the value.
|
|
* @param order The highest order acting on this value.
|
|
* @returns The adjusted value or code that evaluates to it.
|
|
*/
|
|
getAdjusted(
|
|
block: Block,
|
|
atId: string,
|
|
delta = 0,
|
|
negate = false,
|
|
order = Order.NONE,
|
|
): string {
|
|
if (block.workspace.options.oneBasedIndex) {
|
|
delta--;
|
|
}
|
|
const defaultAtIndex = block.workspace.options.oneBasedIndex ? '1' : '0';
|
|
|
|
let orderForInput = order;
|
|
if (delta > 0) {
|
|
orderForInput = Order.ADDITION;
|
|
} else if (delta < 0) {
|
|
orderForInput = Order.SUBTRACTION;
|
|
} else if (negate) {
|
|
orderForInput = Order.UNARY_NEGATION;
|
|
}
|
|
|
|
let at = this.valueToCode(block, atId, orderForInput) || defaultAtIndex;
|
|
|
|
// Easy case: no adjustments.
|
|
if (delta === 0 && !negate) {
|
|
return at;
|
|
}
|
|
// If the index is a naked number, adjust it right now.
|
|
if (stringUtils.isNumber(at)) {
|
|
at = String(Number(at) + delta);
|
|
if (negate) {
|
|
at = String(-Number(at));
|
|
}
|
|
return at;
|
|
}
|
|
// If the index is dynamic, adjust it in code.
|
|
if (delta > 0) {
|
|
at = `${at} + ${delta}`;
|
|
} else if (delta < 0) {
|
|
at = `${at} - ${-delta}`;
|
|
}
|
|
if (negate) {
|
|
at = delta ? `-(${at})` : `-${at}`;
|
|
}
|
|
if (Math.floor(order) >= Math.floor(orderForInput)) {
|
|
at = `(${at})`;
|
|
}
|
|
return at;
|
|
}
|
|
}
|