CodingPirates/blockly
1
0
Fork 0
mirror of https://github.com/google/blockly.git synced 2026-01-04 15:40:08 +01:00
Code Issues Packages Projects Releases Wiki Activity

refactor(generators): Restructure generator modules to contain side effects (#7173)

Browse Source 
* refactor(generators): Move lang.js -> lang/lang_gernator.js

  Move the LangGenerator definitions into their respective
  subdirectories and add a _generator suffix to their filenames,
  i.e. generators/javascript.js  becomes
  generators/javascript/javascript_generator.js.

  This is to keep related code together and allow the `lang/all.js`
  entrypoints to be moved to the top level generators/ directory.

  No goog module IDs were changed, so playground and test code
  that accesses this modules by filename does not need to be modified.

* refactor(generators) Move lang/all.js -> lang.js

  - Move the entrypoints in generators/*/all.js to correspondingly-named
    files in generators/ instead—i.e., generators/javascript/all.js
    becomes generators/javascript.js.

  - Update build_tasks.js accordingly.

* fix(generators): Add missing exports for LuaGenerator, PhpGenerator

  These were inadvertently omitted from #7161 and #7162, respectively.

* refactor(generators): Make block generator modules side-effect free

  - Move declaration of <lang>Generator instance from
    generators/<lang>/<lang>_generator.js to generators/<lang>.js.
  - Move .addReservedWords() calls from generators/<lang>/*.js to
    generators/<lang>.js
  - Modify generators/<lang>/*.js to export block generator functions
    individually, rather than installing on <lang>Generator instance.
  - Modify generators/<lang>.js to import and install block generator
    functions on <lang>Generator instance.

* fix(tests): Fix tests broken by restructuring of generators

  Where these tests needed block generator functions preinstalled
  they should have been importing the Blockly.<Lang>.all module.

  Where they do not need the provided block generator functions
  they can now create their own empty <Lang>Generator instances.

* chore: Update renamings file

  - Fix a malformation in previous entries that was not detected by
    the renaming file validator test.
  - Add entries describing the work done in this and related recent
    PRs.

* fix: Correct minor errors in PR #7173

  - Fix a search-and-replace error in renamings.json5
  - Fix an incorrect-but-usable import in generator_test.js
This commit is contained in:
Christopher Allen
2023-06-20 23:22:44 +01:00
committed by GitHub
parent 021a560ef0
commit 130989763c
64 changed files with 2120 additions and 2046 deletions
Download Patch File Download Diff File Expand all files Collapse all files

329
generators/dart.js
View File

@@ -1,317 +1,44 @@
/**
* @license
* Copyright 2014 Google LLC
* Copyright 2021 Google LLC
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @fileoverview Helper functions for generating Dart for blocks.
* @suppress {checkTypes|globalThis}
* @fileoverview Complete helper functions for generating Dart for
* blocks. This is the entrypoint for dart_compressed.js.
* @suppress {extraRequire}
*/
import * as goog from '../closure/goog/goog.js';
goog.declareModuleId('Blockly.Dart');
goog.declareModuleId('Blockly.Dart.all');
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';
import {DartGenerator} from './dart/dart_generator.js';
import * as colour from './dart/colour.js';
import * as lists from './dart/lists.js';
import * as logic from './dart/logic.js';
import * as loops from './dart/loops.js';
import * as math from './dart/math.js';
import * as procedures from './dart/procedures.js';
import * as text from './dart/text.js';
import * as variables from './dart/variables.js';
import * as variablesDynamic from './dart/variables_dynamic.js';
export * from './dart/dart_generator.js';
/**
* Order of operation ENUMs.
* https://dart.dev/guides/language/language-tour#operators
* @enum {number}
*/
export const Order = {
ATOMIC: 0, // 0 "" ...
UNARY_POSTFIX: 1, // expr++ expr-- () [] . ?.
UNARY_PREFIX: 2, // -expr !expr ~expr ++expr --expr
MULTIPLICATIVE: 3, // * / % ~/
ADDITIVE: 4, // + -
SHIFT: 5, // << >>
BITWISE_AND: 6, // &
BITWISE_XOR: 7, // ^
BITWISE_OR: 8, // |
RELATIONAL: 9, // >= > <= < as is is!
EQUALITY: 10, // == !=
LOGICAL_AND: 11, // &&
LOGICAL_OR: 12, // ||
IF_NULL: 13, // ??
CONDITIONAL: 14, // expr ? expr : expr
CASCADE: 15, // ..
ASSIGNMENT: 16, // = *= /= ~/= %= += -= <<= >>= &= ^= |=
NONE: 99, // (...)
};
/**
* Dart code generator class.
*/
export class DartGenerator extends CodeGenerator {
constructor(name) {
super(name ?? 'Dart');
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) {
this['ORDER_' + key] = Order[key];
}
// 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.
this.addReservedWords(
// https://www.dartlang.org/docs/spec/latest/dart-language-specification.pdf
// Section 16.1.1
'assert,break,case,catch,class,const,continue,default,do,else,enum,' +
'extends,false,final,finally,for,if,in,is,new,null,rethrow,return,' +
'super,switch,this,throw,true,try,var,void,while,with,' +
// https://api.dartlang.org/dart_core.html
'print,identityHashCode,identical,BidirectionalIterator,Comparable,' +
'double,Function,int,Invocation,Iterable,Iterator,List,Map,Match,num,' +
'Pattern,RegExp,Set,StackTrace,String,StringSink,Type,bool,DateTime,' +
'Deprecated,Duration,Expando,Null,Object,RuneIterator,Runes,Stopwatch,' +
'StringBuffer,Symbol,Uri,Comparator,AbstractClassInstantiationError,' +
'ArgumentError,AssertionError,CastError,ConcurrentModificationError,' +
'CyclicInitializationError,Error,Exception,FallThroughError,' +
'FormatException,IntegerDivisionByZeroException,NoSuchMethodError,' +
'NullThrownError,OutOfMemoryError,RangeError,StackOverflowError,' +
'StateError,TypeError,UnimplementedError,UnsupportedError'
);
}
/**
* Initialise the database of variable names.
* @param {!Workspace} workspace Workspace to generate code from.
*/
init(workspace) {
super.init();
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 import statements and variable definitions.
* @param {string} code Generated code.
* @return {string} Completed code.
*/
finish(code) {
// Indent every line.
if (code) {
code = this.prefixLines(code, this.INDENT);
}
code = 'main() {\n' + code + '}';
// Convert the definitions dictionary into a list.
const imports = [];
const definitions = [];
for (let name in this.definitions_) {
const def = this.definitions_[name];
if (def.match(/^import\s/)) {
imports.push(def);
} else {
definitions.push(def);
}
}
// Call Blockly.CodeGenerator's finish.
code = super.finish(code);
this.isInitialized = false;
this.nameDB_.reset();
const allDefs = imports.join('\n') + '\n\n' + definitions.join('\n\n');
return allDefs.replace(/\n\n+/g, '\n\n').replace(/\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 {string} line Line of generated code.
* @return {string} Legal line of code.
*/
scrubNakedValue(line) {
return line + ';\n';
}
/**
* Encode a string as a properly escaped Dart string, complete with quotes.
* @param {string} string Text to encode.
* @return {string} Dart string.
* @protected
*/
quote_(string) {
// Can't use goog.string.quote since $ must also be escaped.
string = string.replace(/\\/g, '\\\\')
.replace(/\n/g, '\\\n')
.replace(/\$/g, '\\$')
.replace(/'/g, '\\\'');
return '\'' + string + '\'';
}
/**
* Encode a string as a properly escaped multiline Dart string, complete with
* quotes.
* @param {string} string Text to encode.
* @return {string} Dart string.
* @protected
*/
multiline_quote_(string) {
const lines = string.split(/\n/g).map(this.quote_);
// Join with the following, plus a newline:
// + '\n' +
return lines.join(' + \'\\n\' + \n');
}
/**
* Common tasks for generating Dart from blocks.
* Handles comments for the specified block and any connected value blocks.
* Calls any statements following this block.
* @param {!Block} block The current block.
* @param {string} code The Dart code created for this block.
* @param {boolean=} opt_thisOnly True to generate code for only this
* statement.
* @return {string} Dart code with comments and subsequent blocks added.
* @protected
*/
scrub_(block, code, opt_thisOnly) {
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);
if (block.getProcedureDef) {
// Use documentation comment for function comments.
commentCode += this.prefixLines(comment + '\n', '/// ');
} else {
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 = opt_thisOnly ? '' : this.blockToCode(nextBlock);
return commentCode + code + nextCode;
}
/**
* Gets a property and adjusts the value while taking into account indexing.
* @param {!Block} block The block.
* @param {string} atId The property ID of the element to get.
* @param {number=} opt_delta Value to add.
* @param {boolean=} opt_negate Whether to negate the value.
* @param {number=} opt_order The highest order acting on this value.
* @return {string|number}
*/
getAdjusted(block, atId, opt_delta, opt_negate, opt_order) {
let delta = opt_delta || 0;
let order = opt_order || this.ORDER_NONE;
if (block.workspace.options.oneBasedIndex) {
delta--;
}
const defaultAtIndex = block.workspace.options.oneBasedIndex ? '1' : '0';
/** @type {number} */
let outerOrder;
let innerOrder;
if (delta) {
outerOrder = this.ORDER_ADDITIVE;
innerOrder = this.ORDER_ADDITIVE;
} else if (opt_negate) {
outerOrder = this.ORDER_UNARY_PREFIX;
innerOrder = this.ORDER_UNARY_PREFIX;
} else {
outerOrder = order;
}
/** @type {string|number} */
let at = this.valueToCode(block, atId, outerOrder) || defaultAtIndex;
if (stringUtils.isNumber(at)) {
// If the index is a naked number, adjust it right now.
at = parseInt(at, 10) + delta;
if (opt_negate) {
at = -at;
}
} else {
// If the index is dynamic, adjust it in code.
if (delta > 0) {
at = at + ' + ' + delta;
} else if (delta < 0) {
at = at + ' - ' + -delta;
}
if (opt_negate) {
if (delta) {
at = '-(' + at + ')';
} else {
at = '-' + at;
}
}
innerOrder = Math.floor(innerOrder);
order = Math.floor(order);
if (innerOrder && order >= innerOrder) {
at = '(' + at + ')';
}
}
return at;
}
}
/**
* Dart code generator.
* Dart code generator instance.
* @type {!DartGenerator}
*/
export const dartGenerator = new DartGenerator();
// Add reserved words. This list should include all words mentioned
// in RESERVED WORDS: comments in the imports above.
dartGenerator.addReservedWords('Html,Math');
// Install per-block-type generator functions:
Object.assign(
dartGenerator.forBlock,
colour, lists, logic, loops, math, procedures,
text, variables, variablesDynamic
);