Linter Demo

Errors: 1

Warnings: 89

File: /home/fstrocco/Dart/dart/benchmark/compiler/lib/src/ssa/codegen.dart

// Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file // for details. All rights reserved. Use of this source code is governed by a // BSD-style license that can be found in the LICENSE file. part of ssa; class SsaCodeGeneratorTask extends CompilerTask { final JavaScriptBackend backend; SsaCodeGeneratorTask(JavaScriptBackend backend) : this.backend = backend, super(backend.compiler); String get name => 'SSA code generator'; NativeEmitter get nativeEmitter => backend.emitter.nativeEmitter; js.Node attachPosition(js.Node node, AstElement element) { return node.withSourceInformation( StartEndSourceInformation.computeSourceInformation(element)); } js.Fun buildJavaScriptFunction(FunctionElement element, List<js.Parameter> parameters, js.Block body) { js.AsyncModifier asyncModifier = element.asyncMarker.isAsync ? (element.asyncMarker.isYielding ? const js.AsyncModifier.asyncStar() : const js.AsyncModifier.async()) : (element.asyncMarker.isYielding ? const js.AsyncModifier.syncStar() : const js.AsyncModifier.sync()); return attachPosition( new js.Fun(parameters, body, asyncModifier: asyncModifier), element); } js.Expression generateCode(CodegenWorkItem work, HGraph graph) { if (work.element.isField) { return generateLazyInitializer(work, graph); } else { return generateMethod(work, graph); } } js.Expression generateLazyInitializer(work, graph) { return measure(() { compiler.tracer.traceGraph("codegen", graph); SsaCodeGenerator codegen = new SsaCodeGenerator(backend, work); codegen.visitGraph(graph); return new js.Fun(codegen.parameters, attachPosition(codegen.body, work.element)); }); } js.Expression generateMethod(CodegenWorkItem work, HGraph graph) { return measure(() { FunctionElement element = work.element; if (element.asyncMarker != AsyncMarker.SYNC) { work.registry.registerAsyncMarker(element); } SsaCodeGenerator codegen = new SsaCodeGenerator(backend, work); codegen.visitGraph(graph); compiler.tracer.traceGraph("codegen", graph); return buildJavaScriptFunction(element, codegen.parameters, codegen.body); }); } } typedef void EntityAction(Entity element); class SsaCodeGenerator implements HVisitor, HBlockInformationVisitor { /** * Returned by [expressionType] to tell how code can be generated for * a subgraph. * - [TYPE_STATEMENT] means that the graph must be generated as a statement, * which is always possible. * - [TYPE_EXPRESSION] means that the graph can be generated as an expression, * or possibly several comma-separated expressions. * - [TYPE_DECLARATION] means that the graph can be generated as an * expression, and that it only generates expressions of the form * variable = expression * which are also valid as parts of a "var" declaration. */ static const int TYPE_STATEMENT = 0; static const int TYPE_EXPRESSION = 1; static const int TYPE_DECLARATION = 2; /** * Whether we are currently generating expressions instead of statements. * This includes declarations, which are generated as expressions. */ bool isGeneratingExpression = false; final JavaScriptBackend backend; final CodegenWorkItem work; final Set<HInstruction> generateAtUseSite; final Set<HInstruction> controlFlowOperators; final Map<Entity, EntityAction> breakAction; final Map<Entity, EntityAction> continueAction; final List<js.Parameter> parameters; js.Block currentContainer; js.Block get body => currentContainer; List<js.Expression> expressionStack; List<js.Block> oldContainerStack; /** * Contains the names of the instructions, as well as the parallel * copies to perform on block transitioning. */ VariableNames variableNames; bool shouldGroupVarDeclarations = false; /** * While generating expressions, we can't insert variable declarations. * Instead we declare them at the start of the function. When minifying * we do this most of the time, because it reduces the size unless there * is only one variable. */ final Set<String> collectedVariableDeclarations; /** * Set of variables and parameters that have already been declared. */ final Set<String> declaredLocals; HGraph currentGraph; // Records a block-information that is being handled specially. // Used to break bad recursion. HBlockInformation currentBlockInformation; // The subgraph is used to delimit traversal for some constructions, e.g., // if branches. SubGraph subGraph; SsaCodeGenerator(this.backend, CodegenWorkItem work) : this.work = work, declaredLocals = new Set<String>(), collectedVariableDeclarations = new Set<String>(), currentContainer = new js.Block.empty(), parameters = <js.Parameter>[], expressionStack = <js.Expression>[], oldContainerStack = <js.Block>[], generateAtUseSite = new Set<HInstruction>(), controlFlowOperators = new Set<HInstruction>(), breakAction = new Map<Entity, EntityAction>(), continueAction = new Map<Entity, EntityAction>(); Compiler get compiler => backend.compiler; NativeEmitter get nativeEmitter => backend.emitter.nativeEmitter; CodegenRegistry get registry => work.registry; bool isGenerateAtUseSite(HInstruction instruction) { return generateAtUseSite.contains(instruction); } bool hasNonBitOpUser(HInstruction instruction, Set<HPhi> phiSet) { for (HInstruction user in instruction.usedBy) { if (user is HPhi) { if (!phiSet.contains(user)) { phiSet.add(user); if (hasNonBitOpUser(user, phiSet)) return true; } } else if (user is! HBitNot && user is! HBinaryBitOp) { return true; } } return false; } bool requiresUintConversion(instruction) { if (instruction.isUInt31(compiler)) return false; // If the result of a bit-operation is only used by other bit // operations, we do not have to convert to an unsigned integer. return hasNonBitOpUser(instruction, new Set<HPhi>()); } /** * If the [instruction] is not `null` it will be used to attach the position * to the [statement]. */ void pushStatement(js.Statement statement, [HInstruction instruction]) { assert(expressionStack.isEmpty); if (instruction != null) { statement = attachLocation(statement, instruction); } currentContainer.statements.add(statement); } void insertStatementAtStart(js.Statement statement) { currentContainer.statements.insert(0, statement); } /** * If the [instruction] is not `null` it will be used to attach the position * to the [expression]. */ pushExpressionAsStatement(js.Expression expression, [HInstruction instruction]) { pushStatement(new js.ExpressionStatement(expression), instruction); } /** * If the [instruction] is not `null` it will be used to attach the position * to the [expression]. */ push(js.Expression expression, [HInstruction instruction]) { if (instruction != null) { expression = attachLocation(expression, instruction); } expressionStack.add(expression); } js.Expression pop() { return expressionStack.removeLast(); } attachLocationToLast(HInstruction instruction) { int index = expressionStack.length - 1; expressionStack[index] = attachLocation(expressionStack[index], instruction); } js.Node attachLocation(js.Node jsNode, HInstruction instruction) { return attachSourceInformation(jsNode, instruction.sourceInformation); } js.Node attachSourceInformation(js.Node jsNode, SourceInformation sourceInformation) { return jsNode.withSourceInformation(sourceInformation); } void preGenerateMethod(HGraph graph) { new SsaInstructionSelection(compiler).visitGraph(graph); new SsaTypeKnownRemover().visitGraph(graph); new SsaTrustedCheckRemover(compiler).visitGraph(graph); new SsaInstructionMerger(generateAtUseSite, compiler).visitGraph(graph); new SsaConditionMerger( generateAtUseSite, controlFlowOperators).visitGraph(graph); SsaLiveIntervalBuilder intervalBuilder = new SsaLiveIntervalBuilder( compiler, generateAtUseSite, controlFlowOperators); intervalBuilder.visitGraph(graph); SsaVariableAllocator allocator = new SsaVariableAllocator( compiler, intervalBuilder.liveInstructions, intervalBuilder.liveIntervals, generateAtUseSite); allocator.visitGraph(graph); variableNames = allocator.names; shouldGroupVarDeclarations = allocator.names.numberOfVariables > 1; } void handleDelayedVariableDeclarations() { // If we have only one variable declaration and the first statement is an // assignment to that variable then we can merge the two. We count the // number of variables in the variable allocator to try to avoid this issue, // but it sometimes happens that the variable allocator introduces a // temporary variable that it later eliminates. if (!collectedVariableDeclarations.isEmpty) { if (collectedVariableDeclarations.length == 1 && currentContainer.statements.length >= 1 && currentContainer.statements[0] is js.ExpressionStatement) { String name = collectedVariableDeclarations.first; js.ExpressionStatement statement = currentContainer.statements[0]; if (statement.expression is js.Assignment) { js.Assignment assignment = statement.expression; if (!assignment.isCompound && assignment.leftHandSide is js.VariableReference) { js.VariableReference variableReference = assignment.leftHandSide; if (variableReference.name == name) { js.VariableDeclaration decl = new js.VariableDeclaration(name); js.VariableInitialization initialization = new js.VariableInitialization(decl, assignment.value); currentContainer.statements[0] = new js.ExpressionStatement( new js.VariableDeclarationList([initialization])); return; } } } } // If we can't merge the declaration with the first assignment then we // just do it with a new var z,y,x; statement. List<js.VariableInitialization> declarations = <js.VariableInitialization>[]; collectedVariableDeclarations.forEach((String name) { declarations.add(new js.VariableInitialization( new js.VariableDeclaration(name), null)); }); var declarationList = new js.VariableDeclarationList(declarations); insertStatementAtStart(new js.ExpressionStatement(declarationList)); } } visitGraph(HGraph graph) { preGenerateMethod(graph); currentGraph = graph; subGraph = new SubGraph(graph.entry, graph.exit); visitBasicBlock(graph.entry); handleDelayedVariableDeclarations(); } void visitSubGraph(SubGraph newSubGraph) { SubGraph oldSubGraph = subGraph; subGraph = newSubGraph; visitBasicBlock(subGraph.start); subGraph = oldSubGraph; } /** * Check whether a sub-graph can be generated as an expression, or even * as a declaration, or if it has to fall back to being generated as * a statement. * Expressions are anything that doesn't generate control flow constructs. * Declarations must only generate assignments on the form "id = expression", * and not, e.g., expressions where the value isn't assigned, or where it's * assigned to something that's not a simple variable. */ int expressionType(HExpressionInformation info) { // The only HExpressionInformation used as part of a HBlockInformation is // current HSubExpressionBlockInformation, so it's the only one reaching // here. If we start using the other HExpressionInformation types too, // this code should be generalized. assert(info is HSubExpressionBlockInformation); HSubExpressionBlockInformation expressionInfo = info; SubGraph limits = expressionInfo.subExpression; // Start assuming that we can generate declarations. If we find a // counter-example, we degrade our assumption to either expression or // statement, and in the latter case, we can return immediately since // it can't get any worse. E.g., a function call where the return value // isn't used can't be in a declaration. int result = TYPE_DECLARATION; HBasicBlock basicBlock = limits.start; do { HInstruction current = basicBlock.first; while (current != basicBlock.last) { // E.g, bounds check. if (current.isControlFlow()) { return TYPE_STATEMENT; } // HFieldSet generates code on the form x.y = ..., which isn't // valid in a declaration, but it also always have no uses, so // it's caught by that test too. assert(current is! HFieldSet || current.usedBy.isEmpty); if (current.usedBy.isEmpty) { result = TYPE_EXPRESSION; } current = current.next; } if (current is HGoto) { basicBlock = basicBlock.successors[0]; } else if (current is HConditionalBranch) { if (generateAtUseSite.contains(current)) { // Short-circuit control flow operator trickery. // Check the second half, which will continue into the join. // (The first half is [inputs[0]], the second half is [successors[0]], // and [successors[1]] is the join-block). basicBlock = basicBlock.successors[0]; } else { // We allow an expression to end on an HIf (a condition expression). return identical(basicBlock, limits.end) ? result : TYPE_STATEMENT; } } else { // Expression-incompatible control flow. return TYPE_STATEMENT; } } while (limits.contains(basicBlock)); return result; } bool isJSExpression(HExpressionInformation info) { return !identical(expressionType(info), TYPE_STATEMENT); } bool isJSCondition(HExpressionInformation info) { HSubExpressionBlockInformation graph = info; SubExpression limits = graph.subExpression; return !identical(expressionType(info), TYPE_STATEMENT) && (limits.end.last is HConditionalBranch); } /** * Generate statements from block information. * If the block information contains expressions, generate only * assignments, and if it ends in a conditional branch, don't generate * the condition. */ void generateStatements(HBlockInformation block) { if (block is HStatementInformation) { block.accept(this); } else { HSubExpressionBlockInformation expression = block; visitSubGraph(expression.subExpression); } } js.Block generateStatementsInNewBlock(HBlockInformation block) { js.Block result = new js.Block.empty(); js.Block oldContainer = currentContainer; currentContainer = result; generateStatements(block); currentContainer = oldContainer; return result; } /** * If the [block] only contains one statement returns that statement. If the * that statement itself is a block, recursively calls this method. * * If the block is empty, returns a new instance of [js.NOP]. */ js.Statement unwrapStatement(js.Block block) { int len = block.statements.length; if (len == 0) return new js.EmptyStatement(); if (len == 1) { js.Statement result = block.statements[0]; if (result is ast.Block) return unwrapStatement(result); return result; } return block; } /** * Generate expressions from block information. */ js.Expression generateExpression(HExpressionInformation expression) { // Currently we only handle sub-expression graphs. assert(expression is HSubExpressionBlockInformation); bool oldIsGeneratingExpression = isGeneratingExpression; isGeneratingExpression = true; List<js.Expression> oldExpressionStack = expressionStack; List<js.Expression> sequenceElements = <js.Expression>[]; expressionStack = sequenceElements; HSubExpressionBlockInformation expressionSubGraph = expression; visitSubGraph(expressionSubGraph.subExpression); expressionStack = oldExpressionStack; isGeneratingExpression = oldIsGeneratingExpression; if (sequenceElements.isEmpty) { // Happens when the initializer, condition or update of a loop is empty. return null; } else if (sequenceElements.length == 1) { return sequenceElements[0]; } else { js.Expression result = sequenceElements.removeLast(); while (sequenceElements.isNotEmpty) { result = new js.Binary(',', sequenceElements.removeLast(), result); } return result; } } /** * Only visits the arguments starting at inputs[HInvoke.ARGUMENTS_OFFSET]. */ List<js.Expression> visitArguments(List<HInstruction> inputs, {int start: HInvoke.ARGUMENTS_OFFSET}) { assert(inputs.length >= start); List<js.Expression> result = new List<js.Expression>(inputs.length - start); for (int i = start; i < inputs.length; i++) { use(inputs[i]); result[i - start] = pop(); } return result; } bool isVariableDeclared(String variableName) { return declaredLocals.contains(variableName) || collectedVariableDeclarations.contains(variableName); } js.Expression generateExpressionAssignment(String variableName, js.Expression value) { if (value is js.Binary) { js.Binary binary = value; String op = binary.op; if (op == '+' || op == '-' || op == '/' || op == '*' || op == '%' || op == '^' || op == '&' || op == '|') { if (binary.left is js.VariableUse && (binary.left as js.VariableUse).name == variableName) { // We know now, that we can shorten x = x + y into x += y. // Also check for the shortcut where y equals 1: x++ and x--. if ((op == '+' || op == '-') && binary.right is js.LiteralNumber && (binary.right as js.LiteralNumber).value == "1") { return new js.Prefix(op == '+' ? '++' : '--', binary.left); } return new js.Assignment.compound(binary.left, op, binary.right); } } } return new js.Assignment(new js.VariableUse(variableName), value); } void assignVariable(String variableName, js.Expression value) { if (isGeneratingExpression) { // If we are in an expression then we can't declare the variable here. // We have no choice, but to use it and then declare it separately. if (!isVariableDeclared(variableName)) { collectedVariableDeclarations.add(variableName); } push(generateExpressionAssignment(variableName, value)); // Otherwise if we are trying to declare inline and we are in a statement // then we declare (unless it was already declared). } else if (!shouldGroupVarDeclarations && !declaredLocals.contains(variableName)) { // It may be necessary to remove it from the ones to be declared later. collectedVariableDeclarations.remove(variableName); declaredLocals.add(variableName); js.VariableDeclaration decl = new js.VariableDeclaration(variableName); js.VariableInitialization initialization = new js.VariableInitialization(decl, value); pushExpressionAsStatement(new js.VariableDeclarationList( <js.VariableInitialization>[initialization])); } else { // Otherwise we are just going to use it. If we have not already declared // it then we make sure we will declare it later. if (!declaredLocals.contains(variableName)) { collectedVariableDeclarations.add(variableName); } pushExpressionAsStatement( generateExpressionAssignment(variableName, value)); } } void define(HInstruction instruction) { // For simple type checks like i = intTypeCheck(i), we don't have to // emit an assignment, because the intTypeCheck just returns its // argument. bool needsAssignment = true; if (instruction is HTypeConversion) { HTypeConversion typeConversion = instruction; String inputName = variableNames.getName(typeConversion.checkedInput); if (variableNames.getName(instruction) == inputName) { needsAssignment = false; } } if (instruction is HLocalValue) { needsAssignment = false; } if (needsAssignment && !instruction.isControlFlow() && variableNames.hasName(instruction)) { visitExpression(instruction); assignVariable(variableNames.getName(instruction), pop()); return; } if (isGeneratingExpression) { visitExpression(instruction); } else { visitStatement(instruction); } } void use(HInstruction argument) { if (isGenerateAtUseSite(argument)) { visitExpression(argument); } else if (argument is HCheck && !variableNames.hasName(argument)) { HCheck check = argument; // This can only happen if the checked node does not have a name. assert(!variableNames.hasName(check.checkedInput)); use(check.checkedInput); } else { assert(variableNames.hasName(argument)); push(new js.VariableUse(variableNames.getName(argument))); } } visit(HInstruction node) { node.accept(this); } visitExpression(HInstruction node) { bool oldIsGeneratingExpression = isGeneratingExpression; isGeneratingExpression = true; visit(node); isGeneratingExpression = oldIsGeneratingExpression; } visitStatement(HInstruction node) { assert(!isGeneratingExpression); visit(node); if (!expressionStack.isEmpty) { assert(expressionStack.length == 1); pushExpressionAsStatement(pop()); } } void continueAsBreak(LabelDefinition target) { pushStatement(new js.Break(backend.namer.continueLabelName(target))); } void implicitContinueAsBreak(JumpTarget target) { pushStatement(new js.Break( backend.namer.implicitContinueLabelName(target))); } void implicitBreakWithLabel(JumpTarget target) { pushStatement(new js.Break(backend.namer.implicitBreakLabelName(target))); } js.Statement wrapIntoLabels(js.Statement result, List<LabelDefinition> labels) { for (LabelDefinition label in labels) { if (label.isTarget) { String breakLabelString = backend.namer.breakLabelName(label); result = new js.LabeledStatement(breakLabelString, result); } } return result; } // The regular [visitIf] method implements the needed logic. bool visitIfInfo(HIfBlockInformation info) => false; bool visitSwitchInfo(HSwitchBlockInformation info) { bool isExpression = isJSExpression(info.expression); if (!isExpression) { generateStatements(info.expression); } if (isExpression) { push(generateExpression(info.expression)); } else { use(info.expression.conditionExpression); } js.Expression key = pop(); List<js.SwitchClause> cases = <js.SwitchClause>[]; HSwitch switchInstruction = info.expression.end.last; List<HInstruction> inputs = switchInstruction.inputs; List<HBasicBlock> successors = switchInstruction.block.successors; js.Block oldContainer = currentContainer; for (int inputIndex = 1, statementIndex = 0; inputIndex < inputs.length; statementIndex++) { HBasicBlock successor = successors[inputIndex - 1]; // If liveness analysis has figured out that this case is dead, // omit the code for it. if (successor.isLive) { do { visit(inputs[inputIndex]); currentContainer = new js.Block.empty(); cases.add(new js.Case(pop(), currentContainer)); inputIndex++; } while ((successors[inputIndex - 1] == successor) && (inputIndex < inputs.length)); generateStatements(info.statements[statementIndex]); } else { // Skip all the case statements that belong to this // block. while ((successors[inputIndex - 1] == successor) && (inputIndex < inputs.length)) { ++inputIndex; } } } // If the default case is dead, we omit it. Likewise, if it is an // empty block, we omit it, too. if (info.statements.last.start.isLive) { currentContainer = new js.Block.empty(); generateStatements(info.statements.last); if (currentContainer.statements.isNotEmpty) { cases.add(new js.Default(currentContainer)); } } currentContainer = oldContainer; js.Statement result = new js.Switch(key, cases); pushStatement(wrapIntoLabels(result, info.labels)); return true; } bool visitSequenceInfo(HStatementSequenceInformation info) { return false; } bool visitSubGraphInfo(HSubGraphBlockInformation info) { visitSubGraph(info.subGraph); return true; } bool visitSubExpressionInfo(HSubExpressionBlockInformation info) { return false; } bool visitAndOrInfo(HAndOrBlockInformation info) { return false; } bool visitTryInfo(HTryBlockInformation info) { js.Block body = generateStatementsInNewBlock(info.body); js.Catch catchPart = null; js.Block finallyPart = null; if (info.catchBlock != null) { void register(ClassElement classElement) { if (classElement != null) { registry.registerInstantiatedClass(classElement); } } register(backend.jsPlainJavaScriptObjectClass); register(backend.jsUnknownJavaScriptObjectClass); HLocalValue exception = info.catchVariable; String name = variableNames.getName(exception); js.VariableDeclaration decl = new js.VariableDeclaration(name); js.Block catchBlock = generateStatementsInNewBlock(info.catchBlock); catchPart = new js.Catch(decl, catchBlock); } if (info.finallyBlock != null) { finallyPart = generateStatementsInNewBlock(info.finallyBlock); } pushStatement(new js.Try(body, catchPart, finallyPart)); return true; } void visitBodyIgnoreLabels(HLoopBlockInformation info) { if (info.body.start.isLabeledBlock()) { HBlockInformation oldInfo = currentBlockInformation; currentBlockInformation = info.body.start.blockFlow.body; generateStatements(info.body); currentBlockInformation = oldInfo; } else { generateStatements(info.body); } } bool visitLoopInfo(HLoopBlockInformation info) { HExpressionInformation condition = info.condition; bool isConditionExpression = isJSCondition(condition); js.Loop loop; switch (info.kind) { // Treate all three "test-first" loops the same way. case HLoopBlockInformation.FOR_LOOP: case HLoopBlockInformation.WHILE_LOOP: case HLoopBlockInformation.FOR_IN_LOOP: case HLoopBlockInformation.SWITCH_CONTINUE_LOOP: HBlockInformation initialization = info.initializer; int initializationType = TYPE_STATEMENT; if (initialization != null) { initializationType = expressionType(initialization); if (initializationType == TYPE_STATEMENT) { generateStatements(initialization); initialization = null; } } // We inserted a basic block to avoid critical edges. This block is // part of the LoopBlockInformation and must therefore be handled here. js.Block oldContainer = currentContainer; js.Block avoidContainer = new js.Block.empty(); currentContainer = avoidContainer; assignPhisOfSuccessors(condition.end.successors.last); bool hasPhiUpdates = !avoidContainer.statements.isEmpty; currentContainer = oldContainer; if (isConditionExpression && !hasPhiUpdates && info.updates != null && isJSExpression(info.updates)) { // If we have an updates graph, and it's expressible as an // expression, generate a for-loop. js.Expression jsInitialization = null; if (initialization != null) { int delayedVariablesCount = collectedVariableDeclarations.length; jsInitialization = generateExpression(initialization); if (!shouldGroupVarDeclarations && delayedVariablesCount < collectedVariableDeclarations.length) { // We just added a new delayed variable-declaration. See if we can // put in a 'var' in front of the initialization to make it go // away. We walk the 'tree' of comma-operators to find the // expressions and see if they are all assignments that can be // converted into declarations. List<js.Assignment> assignments; bool allSimpleAssignments(js.Expression expression) { if (expression is js.Assignment) { js.Assignment assignment = expression; if (assignment.leftHandSide is js.VariableUse && !assignment.isCompound) { if (assignments == null) assignments = <js.Assignment>[]; assignments.add(expression); return true; } } else if (expression.isCommaOperator) { js.Binary binary = expression; return allSimpleAssignments(binary.left) && allSimpleAssignments(binary.right); } return false; } if (allSimpleAssignments(jsInitialization)) { List<js.VariableInitialization> inits = <js.VariableInitialization>[]; for (js.Assignment assignment in assignments) { String id = (assignment.leftHandSide as js.VariableUse).name; js.Node declaration = new js.VariableDeclaration(id); inits.add(new js.VariableInitialization(declaration, assignment.value)); collectedVariableDeclarations.remove(id); declaredLocals.add(id); } jsInitialization = new js.VariableDeclarationList(inits); } } } js.Expression jsCondition = generateExpression(condition); js.Expression jsUpdates = generateExpression(info.updates); // The body might be labeled. Ignore this when recursing on the // subgraph. // TODO(lrn): Remove this extra labeling when handling all loops // using subgraphs. oldContainer = currentContainer; js.Statement body = new js.Block.empty(); currentContainer = body; visitBodyIgnoreLabels(info); currentContainer = oldContainer; body = unwrapStatement(body); loop = new js.For(jsInitialization, jsCondition, jsUpdates, body); } else { // We have either no update graph, or it's too complex to // put in an expression. if (initialization != null) { generateStatements(initialization); } js.Expression jsCondition; js.Block oldContainer = currentContainer; js.Statement body = new js.Block.empty(); if (isConditionExpression && !hasPhiUpdates) { jsCondition = generateExpression(condition); currentContainer = body; } else { jsCondition = newLiteralBool(true); currentContainer = body; generateStatements(condition); use(condition.conditionExpression); js.Expression ifTest = new js.Prefix("!", pop()); js.Statement jsBreak = new js.Break(null); js.Statement exitLoop; if (avoidContainer.statements.isEmpty) { exitLoop = jsBreak; } else { avoidContainer.statements.add(jsBreak); exitLoop = avoidContainer; } pushStatement(new js.If.noElse(ifTest, exitLoop)); } if (info.updates != null) { wrapLoopBodyForContinue(info); generateStatements(info.updates); } else { visitBodyIgnoreLabels(info); } currentContainer = oldContainer; body = unwrapStatement(body); loop = new js.While(jsCondition, body); } break; case HLoopBlockInformation.DO_WHILE_LOOP: if (info.initializer != null) { generateStatements(info.initializer); } // We inserted a basic block to avoid critical edges. This block is // part of the LoopBlockInformation and must therefore be handled here. js.Block oldContainer = currentContainer; js.Block exitAvoidContainer = new js.Block.empty(); currentContainer = exitAvoidContainer; assignPhisOfSuccessors(condition.end.successors.last); bool hasExitPhiUpdates = !exitAvoidContainer.statements.isEmpty; currentContainer = oldContainer; oldContainer = currentContainer; js.Block body = new js.Block.empty(); // If there are phi copies in the block that jumps to the // loop entry, we must emit the condition like this: // do { // body; // if (condition) { // phi updates; // continue; // } else { // break; // } // } while (true); HBasicBlock avoidEdge = info.end.successors[0]; js.Block updateBody = new js.Block.empty(); currentContainer = updateBody; assignPhisOfSuccessors(avoidEdge); bool hasPhiUpdates = !updateBody.statements.isEmpty; currentContainer = body; visitBodyIgnoreLabels(info); if (info.updates != null) { generateStatements(info.updates); } if (isConditionExpression) { push(generateExpression(condition)); } else { generateStatements(condition); use(condition.conditionExpression); } js.Expression jsCondition = pop(); if (jsCondition == null) { // If the condition is dead code, we turn the do-while into // a simpler while because we will never reach the condition // at the end of the loop anyway. loop = new js.While(newLiteralBool(true), unwrapStatement(body)); } else { if (hasPhiUpdates || hasExitPhiUpdates) { updateBody.statements.add(new js.Continue(null)); js.Statement jsBreak = new js.Break(null); js.Statement exitLoop; if (exitAvoidContainer.statements.isEmpty) { exitLoop = jsBreak; } else { exitAvoidContainer.statements.add(jsBreak); exitLoop = exitAvoidContainer; } body.statements.add( new js.If(jsCondition, updateBody, exitLoop)); jsCondition = newLiteralBool(true); } loop = new js.Do(unwrapStatement(body), jsCondition); } currentContainer = oldContainer; break; default: compiler.internalError(condition.conditionExpression, 'Unexpected loop kind: ${info.kind}.'); } js.Statement result = attachSourceInformation(loop, info.sourceInformation); if (info.kind == HLoopBlockInformation.SWITCH_CONTINUE_LOOP) { String continueLabelString = backend.namer.implicitContinueLabelName(info.target); result = new js.LabeledStatement(continueLabelString, result); } pushStatement(wrapIntoLabels(result, info.labels)); return true; } bool visitLabeledBlockInfo(HLabeledBlockInformation labeledBlockInfo) { Link<Entity> continueOverrides = const Link<Entity>(); js.Block oldContainer = currentContainer; js.Block body = new js.Block.empty(); js.Statement result = body; currentContainer = body; // If [labeledBlockInfo.isContinue], the block is an artificial // block around the body of a loop with an update block, so that // continues of the loop can be written as breaks of the body // block. if (labeledBlockInfo.isContinue) { for (LabelDefinition label in labeledBlockInfo.labels) { if (label.isContinueTarget) { String labelName = backend.namer.continueLabelName(label); result = new js.LabeledStatement(labelName, result); continueAction[label] = continueAsBreak; continueOverrides = continueOverrides.prepend(label); } } // For handling unlabeled continues from the body of a loop. // TODO(lrn): Consider recording whether the target is in fact // a target of an unlabeled continue, and not generate this if it isn't. JumpTarget target = labeledBlockInfo.target; String labelName = backend.namer.implicitContinueLabelName(target); result = new js.LabeledStatement(labelName, result); continueAction[target] = implicitContinueAsBreak; continueOverrides = continueOverrides.prepend(target); } else { for (LabelDefinition label in labeledBlockInfo.labels) { if (label.isBreakTarget) { String labelName = backend.namer.breakLabelName(label); result = new js.LabeledStatement(labelName, result); } } } JumpTarget target = labeledBlockInfo.target; if (target.isSwitch) { // This is an extra block around a switch that is generated // as a nested if/else chain. We add an extra break target // so that case code can break. String labelName = backend.namer.implicitBreakLabelName(target); result = new js.LabeledStatement(labelName, result); breakAction[target] = implicitBreakWithLabel; } currentContainer = body; generateStatements(labeledBlockInfo.body); if (labeledBlockInfo.isContinue) { while (!continueOverrides.isEmpty) { continueAction.remove(continueOverrides.head); continueOverrides = continueOverrides.tail; } } else { breakAction.remove(labeledBlockInfo.target); } currentContainer = oldContainer; pushStatement(result); return true; } // Wraps a loop body in a block to make continues have a target to break // to (if necessary). void wrapLoopBodyForContinue(HLoopBlockInformation info) { JumpTarget target = info.target; if (target != null && target.isContinueTarget) { js.Block oldContainer = currentContainer; js.Block body = new js.Block.empty(); currentContainer = body; js.Statement result = body; for (LabelDefinition label in info.labels) { if (label.isContinueTarget) { String labelName = backend.namer.continueLabelName(label); result = new js.LabeledStatement(labelName, result); continueAction[label] = continueAsBreak; } } String labelName = backend.namer.implicitContinueLabelName(target); result = new js.LabeledStatement(labelName, result); continueAction[info.target] = implicitContinueAsBreak; visitBodyIgnoreLabels(info); continueAction.remove(info.target); for (LabelDefinition label in info.labels) { if (label.isContinueTarget) { continueAction.remove(label); } } currentContainer = oldContainer; pushStatement(result); } else { // Loop body contains no continues, so we don't need a break target. generateStatements(info.body); } } bool handleBlockFlow(HBlockFlow block) { HBlockInformation info = block.body; // If we reach here again while handling the attached information, // e.g., because we call visitSubGraph on a subgraph starting on // the same block, don't handle it again. // When the structure graph is complete, we will be able to have // different structures starting on the same basic block (e.g., an // "if" and its condition). if (identical(info, currentBlockInformation)) return false; HBlockInformation oldBlockInformation = currentBlockInformation; currentBlockInformation = info; bool success = info.accept(this); currentBlockInformation = oldBlockInformation; if (success) { HBasicBlock continuation = block.continuation; if (continuation != null) { visitBasicBlock(continuation); } } return success; } void visitBasicBlock(HBasicBlock node) { if (!node.isLive) return; // Abort traversal if we are leaving the currently active sub-graph. if (!subGraph.contains(node)) return; // If this node has block-structure based information attached, // try using that to traverse from here. if (node.blockFlow != null && handleBlockFlow(node.blockFlow)) { return; } iterateBasicBlock(node); } void emitAssignment(String destination, String source) { assignVariable(destination, new js.VariableUse(source)); } /** * Sequentialize a list of conceptually parallel copies. Parallel * copies may contain cycles, that this method breaks. */ void sequentializeCopies(Iterable<Copy> copies, String tempName, void doAssignment(String target, String source)) { // Map to keep track of the current location (ie the variable that // holds the initial value) of a variable. Map<String, String> currentLocation = new Map<String, String>(); // Map to keep track of the initial value of a variable. Map<String, String> initialValue = new Map<String, String>(); // List of variables to assign a value. List<String> worklist = <String>[]; // List of variables that we can assign a value to (ie are not // being used anymore). List<String> ready = <String>[]; // Prune [copies] by removing self-copies. List<Copy> prunedCopies = <Copy>[]; for (Copy copy in copies) { if (copy.source != copy.destination) { prunedCopies.add(copy); } } copies = prunedCopies; // For each copy, set the current location of the source to // itself, and the initial value of the destination to the source. // Add the destination to the list of copies to make. for (Copy copy in copies) { currentLocation[copy.source] = copy.source; initialValue[copy.destination] = copy.source; worklist.add(copy.destination); } // For each copy, if the destination does not have a current // location, then we can safely assign to it. for (Copy copy in copies) { if (currentLocation[copy.destination] == null) { ready.add(copy.destination); } } while (!worklist.isEmpty) { while (!ready.isEmpty) { String destination = ready.removeLast(); String source = initialValue[destination]; // Since [source] might have been updated, use the current // location of [source] String copy = currentLocation[source]; doAssignment(destination, copy); // Now [destination] is the current location of [source]. currentLocation[source] = destination; // If [source] hasn't been updated and needs to have a value, // add it to the list of variables that can be updated. Copies // of [source] will now use [destination]. if (source == copy && initialValue[source] != null) { ready.add(source); } } // Check if we have a cycle. String current = worklist.removeLast(); // If [current] is used as a source, and the assignment has been // done, we are done with this variable. Otherwise there is a // cycle that we break by using a temporary name. if (currentLocation[current] != null && current != currentLocation[initialValue[current]]) { doAssignment(tempName, current); currentLocation[current] = tempName; // [current] can now be safely updated. Copies of [current] // will now use [tempName]. ready.add(current); } } } void assignPhisOfSuccessors(HBasicBlock node) { CopyHandler handler = variableNames.getCopyHandler(node); if (handler == null) return; // Map the instructions to strings. Iterable<Copy> copies = handler.copies.map((Copy copy) { return new Copy(variableNames.getName(copy.source), variableNames.getName(copy.destination)); }); sequentializeCopies(copies, variableNames.getSwapTemp(), emitAssignment); for (Copy copy in handler.assignments) { String name = variableNames.getName(copy.destination); use(copy.source); assignVariable(name, pop()); } } void iterateBasicBlock(HBasicBlock node) { HInstruction instruction = node.first; while (!identical(instruction, node.last)) { if (!isGenerateAtUseSite(instruction)) { define(instruction); } instruction = instruction.next; } assignPhisOfSuccessors(node); visit(instruction); } visitInvokeBinary(HInvokeBinary node, String op) { use(node.left); js.Expression jsLeft = pop(); use(node.right); push(new js.Binary(op, jsLeft, pop()), node); } visitRelational(HRelational node, String op) => visitInvokeBinary(node, op); // We want the outcome of bit-operations to be positive. We use the unsigned // shift operator to achieve this. visitBitInvokeBinary(HBinaryBitOp node, String op) { visitInvokeBinary(node, op); if (op != '>>>' && requiresUintConversion(node)) { push(new js.Binary(">>>", pop(), new js.LiteralNumber("0")), node); } } visitInvokeUnary(HInvokeUnary node, String op) { use(node.operand); push(new js.Prefix(op, pop()), node); } // We want the outcome of bit-operations to be positive. We use the unsigned // shift operator to achieve this. visitBitInvokeUnary(HInvokeUnary node, String op) { visitInvokeUnary(node, op); if (requiresUintConversion(node)) { push(new js.Binary(">>>", pop(), new js.LiteralNumber("0")), node); } } void emitIdentityComparison(HIdentity instruction, bool inverse) { String op = instruction.singleComparisonOp; HInstruction left = instruction.left; HInstruction right = instruction.right; if (op != null) { use(left); js.Expression jsLeft = pop(); use(right); push(new js.Binary(mapRelationalOperator(op, inverse), jsLeft, pop())); } else { assert(NullConstantValue.JsNull == 'null'); use(left); js.Binary leftEqualsNull = new js.Binary("==", pop(), new js.LiteralNull()); use(right); js.Binary rightEqualsNull = new js.Binary(mapRelationalOperator("==", inverse), pop(), new js.LiteralNull()); use(right); use(left); js.Binary tripleEq = new js.Binary(mapRelationalOperator("===", inverse), pop(), pop()); push(new js.Conditional(leftEqualsNull, rightEqualsNull, tripleEq)); } } visitIdentity(HIdentity node) { emitIdentityComparison(node, false); } visitAdd(HAdd node) => visitInvokeBinary(node, '+'); visitDivide(HDivide node) => visitInvokeBinary(node, '/'); visitMultiply(HMultiply node) => visitInvokeBinary(node, '*'); visitSubtract(HSubtract node) => visitInvokeBinary(node, '-'); visitBitAnd(HBitAnd node) => visitBitInvokeBinary(node, '&'); visitBitNot(HBitNot node) => visitBitInvokeUnary(node, '~'); visitBitOr(HBitOr node) => visitBitInvokeBinary(node, '|'); visitBitXor(HBitXor node) => visitBitInvokeBinary(node, '^'); visitShiftLeft(HShiftLeft node) => visitBitInvokeBinary(node, '<<'); visitShiftRight(HShiftRight node) => visitBitInvokeBinary(node, '>>>'); visitTruncatingDivide(HTruncatingDivide node) { assert(node.left.isUInt31(compiler)); assert(node.right.isPositiveInteger(compiler)); use(node.left); js.Expression jsLeft = pop(); use(node.right); push(new js.Binary('/', jsLeft, pop()), node); push(new js.Binary('|', pop(), new js.LiteralNumber("0")), node); } visitNegate(HNegate node) => visitInvokeUnary(node, '-'); visitLess(HLess node) => visitRelational(node, '<'); visitLessEqual(HLessEqual node) => visitRelational(node, '<='); visitGreater(HGreater node) => visitRelational(node, '>'); visitGreaterEqual(HGreaterEqual node) => visitRelational(node, '>='); visitBoolify(HBoolify node) { assert(node.inputs.length == 1); use(node.inputs[0]); push(new js.Binary('===', pop(), newLiteralBool(true)), node); } visitExit(HExit node) { // Don't do anything. } visitGoto(HGoto node) { HBasicBlock block = node.block; assert(block.successors.length == 1); List<HBasicBlock> dominated = block.dominatedBlocks; // With the exception of the entry-node which dominates its successor // and the exit node, no block finishing with a 'goto' can have more than // one dominated block (since it has only one successor). // If the successor is dominated by another block, then the other block // is responsible for visiting the successor. if (dominated.isEmpty) return; if (dominated.length > 2) { compiler.internalError(node, 'dominated.length = ${dominated.length}'); } if (dominated.length == 2 && block != currentGraph.entry) { compiler.internalError(node, 'node.block != currentGraph.entry'); } assert(dominated[0] == block.successors[0]); visitBasicBlock(dominated[0]); } visitLoopBranch(HLoopBranch node) { assert(node.block == subGraph.end); // We are generating code for a loop condition. // If we are generating the subgraph as an expression, the // condition will be generated as the expression. // Otherwise, we don't generate the expression, and leave that // to the code that called [visitSubGraph]. if (isGeneratingExpression) { use(node.inputs[0]); } } /** * Checks if [map] contains an [EntityAction] for [entity], and * if so calls that action and returns true. * Otherwise returns false. */ bool tryCallAction(Map<Entity, EntityAction> map, Entity entity) { EntityAction action = map[entity]; if (action == null) return false; action(entity); return true; } visitBreak(HBreak node) { assert(node.block.successors.length == 1); if (node.label != null) { LabelDefinition label = node.label; if (!tryCallAction(breakAction, label)) { pushStatement(new js.Break(backend.namer.breakLabelName(label)), node); } } else { JumpTarget target = node.target; if (!tryCallAction(breakAction, target)) { if (node.breakSwitchContinueLoop) { pushStatement(new js.Break( backend.namer.implicitContinueLabelName(target)), node); } else { pushStatement(new js.Break(null), node); } } } } visitContinue(HContinue node) { assert(node.block.successors.length == 1); if (node.label != null) { LabelDefinition label = node.label; if (!tryCallAction(continueAction, label)) { // TODO(floitsch): should this really be the breakLabelName? pushStatement(new js.Continue(backend.namer.breakLabelName(label)), node); } } else { JumpTarget target = node.target; if (!tryCallAction(continueAction, target)) { if (target.statement is ast.SwitchStatement) { pushStatement(new js.Continue( backend.namer.implicitContinueLabelName(target)), node); } else { pushStatement(new js.Continue(null), node); } } } } visitExitTry(HExitTry node) { // An [HExitTry] is used to represent the control flow graph of a // try/catch block, ie the try body is always a predecessor // of the catch and finally. Here, we continue visiting the try // body by visiting the block that contains the user-level control // flow instruction. visitBasicBlock(node.bodyTrySuccessor); } visitTry(HTry node) { // We should never get here. Try/catch/finally is always handled using block // information in [visitTryInfo]. compiler.internalError(node, 'visitTry should not be called.'); } bool tryControlFlowOperation(HIf node) { if (!controlFlowOperators.contains(node)) return false; HPhi phi = node.joinBlock.phis.first; bool atUseSite = isGenerateAtUseSite(phi); // Don't generate a conditional operator in this situation: // i = condition ? bar() : i; // But generate this instead: // if (condition) i = bar(); // Usually, the variable name is longer than 'if' and it takes up // more space to duplicate the name. if (!atUseSite && variableNames.getName(phi) == variableNames.getName(phi.inputs[1])) { return false; } if (!atUseSite) define(phi); visitBasicBlock(node.joinBlock); return true; } void generateIf(HIf node, HIfBlockInformation info) { use(node.inputs[0]); js.Expression test = pop(); HStatementInformation thenGraph = info.thenGraph; HStatementInformation elseGraph = info.elseGraph; js.Statement thenPart = unwrapStatement(generateStatementsInNewBlock(thenGraph)); js.Statement elsePart = unwrapStatement(generateStatementsInNewBlock(elseGraph)); pushStatement(new js.If(test, thenPart, elsePart), node); } visitIf(HIf node) { if (tryControlFlowOperation(node)) return; HInstruction condition = node.inputs[0]; HIfBlockInformation info = node.blockInformation.body; if (condition.isConstant()) { HConstant constant = condition; if (constant.constant.isTrue) { generateStatements(info.thenGraph); } else { generateStatements(info.elseGraph); } } else { generateIf(node, info); } HBasicBlock joinBlock = node.joinBlock; if (joinBlock != null && !identical(joinBlock.dominator, node.block)) { // The join block is dominated by a block in one of the branches. // The subgraph traversal never reached it, so we visit it here // instead. visitBasicBlock(joinBlock); } // Visit all the dominated blocks that are not part of the then or else // branches, and is not the join block. // Depending on how the then/else branches terminate // (e.g., return/throw/break) there can be any number of these. List<HBasicBlock> dominated = node.block.dominatedBlocks; for (int i = 2; i < dominated.length; i++) { visitBasicBlock(dominated[i]); } } void visitInterceptor(HInterceptor node) { if (node.isConditionalConstantInterceptor) { assert(node.inputs.length == 2); use(node.receiver); js.Expression receiverExpression = pop(); use(node.conditionalConstantInterceptor); js.Expression constant = pop(); push(js.js('# && #', [receiverExpression, constant])); } else { assert(node.inputs.length == 1); registry.registerSpecializedGetInterceptor(node.interceptedClasses); String name = backend.namer.nameForGetInterceptor(node.interceptedClasses); var isolate = new js.VariableUse( backend.namer.globalObjectFor(backend.interceptorsLibrary)); use(node.receiver); List<js.Expression> arguments = <js.Expression>[pop()]; push(js.propertyCall(isolate, name, arguments), node); registry.registerUseInterceptor(); } } visitInvokeDynamicMethod(HInvokeDynamicMethod node) { use(node.receiver); js.Expression object = pop(); String name = node.selector.name; String methodName; List<js.Expression> arguments = visitArguments(node.inputs); Element target = node.element; if (target != null && !node.isInterceptedCall) { if (target == backend.jsArrayAdd) { methodName = 'push'; } else if (target == backend.jsArrayRemoveLast) { methodName = 'pop'; } else if (target == backend.jsStringSplit) { methodName = 'split'; // Split returns a List, so we make sure the backend knows the // list class is instantiated. registry.registerInstantiatedClass(compiler.listClass); } else if (target.isNative && target.isFunction && !node.isInterceptedCall) { // A direct (i.e. non-interceptor) native call is the result of // optimization. The optimization ensures any type checks or // conversions have been satisified. methodName = target.fixedBackendName; } } if (methodName == null) { methodName = backend.namer.invocationName(node.selector); registerMethodInvoke(node); } push(js.propertyCall(object, methodName, arguments), node); } void visitInvokeConstructorBody(HInvokeConstructorBody node) { use(node.inputs[0]); js.Expression object = pop(); String methodName = backend.namer.instanceMethodName(node.element); List<js.Expression> arguments = visitArguments(node.inputs); push(js.propertyCall(object, methodName, arguments), node); registry.registerStaticUse(node.element); } void visitOneShotInterceptor(HOneShotInterceptor node) { List<js.Expression> arguments = visitArguments(node.inputs); var isolate = new js.VariableUse( backend.namer.globalObjectFor(backend.interceptorsLibrary)); Selector selector = getOptimizedSelectorFor(node, node.selector); String methodName = backend.registerOneShotInterceptor(selector); push(js.propertyCall(isolate, methodName, arguments), node); if (selector.isGetter) { registerGetter(node); } else if (selector.isSetter) { registerSetter(node); } else { registerMethodInvoke(node); } registry.registerUseInterceptor(); } Selector getOptimizedSelectorFor(HInvokeDynamic node, Selector selector) { if (node.element != null) { // Create an artificial type mask to make sure only // [node.element] will be enqueued. We're not using the receiver // type because our optimizations might end up in a state where the // invoke dynamic knows more than the receiver. ClassElement enclosing = node.element.enclosingClass; TypeMask receiverType = new TypeMask.nonNullExact(enclosing.declaration, compiler.world); return new TypedSelector(receiverType, selector, compiler.world); } // If [JSInvocationMirror._invokeOn] is enabled, and this call // might hit a `noSuchMethod`, we register an untyped selector. return selector.extendIfReachesAll(compiler); } void registerMethodInvoke(HInvokeDynamic node) { Selector selector = getOptimizedSelectorFor(node, node.selector); // If we don't know what we're calling or if we are calling a getter, // we need to register that fact that we may be calling a closure // with the same arguments. Element target = node.element; if (target == null || target.isGetter) { // TODO(kasperl): If we have a typed selector for the call, we // may know something about the types of closures that need // the specific closure call method. Selector call = new Selector.callClosureFrom(selector); registry.registerDynamicInvocation(call); } registry.registerDynamicInvocation(selector); } void registerSetter(HInvokeDynamic node) { Selector selector = getOptimizedSelectorFor(node, node.selector); registry.registerDynamicSetter(selector); } void registerGetter(HInvokeDynamic node) { Selector selector = getOptimizedSelectorFor(node, node.selector); registry.registerDynamicGetter(selector); } visitInvokeDynamicSetter(HInvokeDynamicSetter node) { use(node.receiver); String name = backend.namer.invocationName(node.selector); push(js.propertyCall(pop(), name, visitArguments(node.inputs)), node); registerSetter(node); } visitInvokeDynamicGetter(HInvokeDynamicGetter node) { use(node.receiver); String name = backend.namer.invocationName(node.selector); push(js.propertyCall(pop(), name, visitArguments(node.inputs)), node); registerGetter(node); } visitInvokeClosure(HInvokeClosure node) { Selector call = new Selector.callClosureFrom(node.selector); use(node.receiver); push(js.propertyCall(pop(), backend.namer.invocationName(call), visitArguments(node.inputs)), node); registry.registerDynamicInvocation(call); } visitInvokeStatic(HInvokeStatic node) { Element element = node.element; List<DartType> instantiatedTypes = node.instantiatedTypes; registry.registerStaticInvocation(element); if (instantiatedTypes != null && !instantiatedTypes.isEmpty) { instantiatedTypes.forEach((type) { registry.registerInstantiatedType(type); }); } push(backend.emitter.staticFunctionAccess(node.element)); push(new js.Call(pop(), visitArguments(node.inputs, start: 0)), node); } visitInvokeSuper(HInvokeSuper node) { Element superMethod = node.element; registry.registerSuperInvocation(superMethod); ClassElement superClass = superMethod.enclosingClass; if (superMethod.kind == ElementKind.FIELD) { String fieldName = backend.namer.instanceFieldPropertyName(superMethod); use(node.inputs[0]); js.PropertyAccess access = new js.PropertyAccess.field(pop(), fieldName); if (node.isSetter) { use(node.value); push(new js.Assignment(access, pop()), node); } else { push(access, node); } } else { Selector selector = node.selector; if (!backend.maybeRegisterAliasedSuperMember(superMethod, selector)) { String methodName; if (selector.isGetter) { // If the selector we need to register a typed getter to the // [world]. The emitter needs to know if it needs to emit a // bound closure for a method. TypeMask receiverType = new TypeMask.nonNullExact(superClass, compiler.world); selector = new TypedSelector(receiverType, selector, compiler.world); // TODO(floitsch): we know the target. We shouldn't register a // dynamic getter. registry.registerDynamicGetter(selector); registry.registerGetterForSuperMethod(node.element); methodName = backend.namer.invocationName(selector); } else { assert(invariant(node, compiler.hasIncrementalSupport)); methodName = backend.namer.instanceMethodName(superMethod); } push(js.js('#.#.call(#)', [backend.emitter.prototypeAccess(superClass, hasBeenInstantiated: true), methodName, visitArguments(node.inputs, start: 0)]), node); } else { use(node.receiver); push( js.js('#.#(#)', [ pop(), backend.namer.aliasedSuperMemberPropertyName(superMethod), visitArguments(node.inputs, start: 1)]), // Skip receiver argument. node); } } } visitFieldGet(HFieldGet node) { use(node.receiver); Element element = node.element; if (node.isNullCheck) { // We access a JavaScript member we know all objects besides // null and undefined have: V8 does not like accessing a member // that does not exist. push(new js.PropertyAccess.field(pop(), 'toString'), node); } else if (element == backend.jsIndexableLength) { // We're accessing a native JavaScript property called 'length' // on a JS String or a JS array. Therefore, the name of that // property should not be mangled. push(new js.PropertyAccess.field(pop(), 'length'), node); } else { String name = backend.namer.instanceFieldPropertyName(element); push(new js.PropertyAccess.field(pop(), name), node); registry.registerFieldGetter(element); } } visitFieldSet(HFieldSet node) { Element element = node.element; registry.registerFieldSetter(element); String name = backend.namer.instanceFieldPropertyName(element); use(node.receiver); js.Expression receiver = pop(); use(node.value); push(new js.Assignment(new js.PropertyAccess.field(receiver, name), pop()), node); } visitReadModifyWrite(HReadModifyWrite node) { Element element = node.element; registry.registerFieldSetter(element); String name = backend.namer.instanceFieldPropertyName(element); use(node.receiver); js.Expression fieldReference = new js.PropertyAccess.field(pop(), name); if (node.isPreOp) { push(new js.Prefix(node.jsOp, fieldReference), node); } else if (node.isPostOp) { push(new js.Postfix(node.jsOp, fieldReference), node); } else { use(node.value); push(new js.Assignment.compound(fieldReference, node.jsOp, pop()), node); } } visitLocalGet(HLocalGet node) { use(node.receiver); } visitLocalSet(HLocalSet node) { use(node.value); assignVariable(variableNames.getName(node.receiver), pop()); } void registerForeignTypes(HForeign node) { native.NativeBehavior nativeBehavior = node.nativeBehavior; if (nativeBehavior == null) return; nativeBehavior.typesReturned.forEach((type) { if (type is InterfaceType) { registry.registerInstantiatedType(type); } }); } visitForeignCode(HForeignCode node) { List<HInstruction> inputs = node.inputs; if (node.isJsStatement()) { List<js.Expression> interpolatedExpressions = <js.Expression>[]; for (int i = 0; i < inputs.length; i++) { use(inputs[i]); interpolatedExpressions.add(pop()); } pushStatement(node.codeTemplate.instantiate(interpolatedExpressions)); } else { List<js.Expression> interpolatedExpressions = <js.Expression>[]; for (int i = 0; i < inputs.length; i++) { use(inputs[i]); interpolatedExpressions.add(pop()); } push(node.codeTemplate.instantiate(interpolatedExpressions)); } // TODO(sra): Tell world.nativeEnqueuer about the types created here. registerForeignTypes(node); } visitForeignNew(HForeignNew node) { js.Expression jsClassReference = backend.emitter.constructorAccess(node.element); List<js.Expression> arguments = visitArguments(node.inputs, start: 0); push(new js.New(jsClassReference, arguments), node); registerForeignTypes(node); if (node.instantiatedTypes == null) { return; } node.instantiatedTypes.forEach((type) { registry.registerInstantiatedType(type); }); } js.Expression newLiteralBool(bool value) { if (compiler.enableMinification) { // Use !0 for true, !1 for false. return new js.Prefix("!", new js.LiteralNumber(value ? "0" : "1")); } else { return new js.LiteralBool(value); } } void generateConstant(ConstantValue constant) { if (constant.isFunction) { FunctionConstantValue function = constant; registry.registerStaticUse(function.element); } if (constant.isType) { // If the type is a web component, we need to ensure the constructors are // available to 'upgrade' the native object. TypeConstantValue type = constant; Element element = type.representedType.element; if (element != null && element.isClass) { registry.registerTypeConstant(element); } } push(backend.emitter.constantReference(constant)); } visitConstant(HConstant node) { assert(isGenerateAtUseSite(node)); generateConstant(node.constant); registry.registerCompileTimeConstant(node.constant); backend.constants.addCompileTimeConstantForEmission(node.constant); } visitNot(HNot node) { assert(node.inputs.length == 1); generateNot(node.inputs[0]); attachLocationToLast(node); } static String mapRelationalOperator(String op, bool inverse) { Map<String, String> inverseOperator = const <String, String>{ "==" : "!=", "!=" : "==", "===": "!==", "!==": "===", "<" : ">=", "<=" : ">", ">" : "<=", ">=" : "<" }; return inverse ? inverseOperator[op] : op; } void generateNot(HInstruction input) { bool canGenerateOptimizedComparison(HInstruction instruction) { if (instruction is !HRelational) return false; HRelational relational = instruction; BinaryOperation operation = relational.operation(backend.constantSystem); HInstruction left = relational.left; HInstruction right = relational.right; if (left.isStringOrNull(compiler) && right.isStringOrNull(compiler)) { return true; } // This optimization doesn't work for NaN, so we only do it if the // type is known to be an integer. return left.isInteger(compiler) && right.isInteger(compiler); } bool handledBySpecialCase = false; if (isGenerateAtUseSite(input)) { handledBySpecialCase = true; if (input is HIs) { emitIs(input, '!=='); } else if (input is HIsViaInterceptor) { emitIsViaInterceptor(input, true); } else if (input is HNot) { use(input.inputs[0]); } else if (input is HIdentity) { emitIdentityComparison(input, true); } else if (input is HBoolify) { use(input.inputs[0]); push(new js.Binary("!==", pop(), newLiteralBool(true)), input); } else if (canGenerateOptimizedComparison(input)) { HRelational relational = input; BinaryOperation operation = relational.operation(backend.constantSystem); String op = mapRelationalOperator(operation.name, true); visitRelational(input, op); } else { handledBySpecialCase = false; } } if (!handledBySpecialCase) { use(input); push(new js.Prefix("!", pop())); } } visitParameterValue(HParameterValue node) { assert(!isGenerateAtUseSite(node)); String name = variableNames.getName(node); parameters.add(new js.Parameter(name)); declaredLocals.add(name); } visitLocalValue(HLocalValue node) { assert(!isGenerateAtUseSite(node)); String name = variableNames.getName(node); collectedVariableDeclarations.add(name); } visitPhi(HPhi node) { // This method is only called for phis that are generated at use // site. A phi can be generated at use site only if it is the // result of a control flow operation. HBasicBlock ifBlock = node.block.dominator; assert(controlFlowOperators.contains(ifBlock.last)); HInstruction input = ifBlock.last.inputs[0]; if (input.isConstantFalse()) { use(node.inputs[1]); } else if (input.isConstantTrue()) { use(node.inputs[0]); } else if (node.inputs[1].isConstantBoolean()) { String operation = node.inputs[1].isConstantFalse() ? '&&' : '||'; if (operation == '||') { generateNot(input); } else { use(input); } js.Expression left = pop(); use(node.inputs[0]); push(new js.Binary(operation, left, pop())); } else { use(input); js.Expression test = pop(); use(node.inputs[0]); js.Expression then = pop(); use(node.inputs[1]); push(new js.Conditional(test, then, pop())); } } visitReturn(HReturn node) { assert(node.inputs.length == 1); HInstruction input = node.inputs[0]; if (input.isConstantNull()) { pushStatement(new js.Return(null), node); } else { use(node.inputs[0]); pushStatement(new js.Return(pop()), node); } } visitThis(HThis node) { push(new js.This()); } visitThrow(HThrow node) { if (node.isRethrow) { use(node.inputs[0]); pushStatement(new js.Throw(pop()), node); } else { generateThrowWithHelper('wrapException', node.inputs[0]); } } visitAwait(HAwait node) { use(node.inputs[0]); push(new js.Await(pop()), node); } visitYield(HYield node) { use(node.inputs[0]); pushStatement(new js.DartYield(pop(), node.hasStar), node); } visitRangeConversion(HRangeConversion node) { // Range conversion instructions are removed by the value range // analyzer. assert(false); } visitBoundsCheck(HBoundsCheck node) { // TODO(ngeoffray): Separate the two checks of the bounds check, so, // e.g., the zero checks can be shared if possible. // If the checks always succeeds, we would have removed the bounds check // completely. assert(node.staticChecks != HBoundsCheck.ALWAYS_TRUE); if (node.staticChecks != HBoundsCheck.ALWAYS_FALSE) { js.Expression under; js.Expression over; if (node.staticChecks != HBoundsCheck.ALWAYS_ABOVE_ZERO) { use(node.index); if (node.index.isInteger(compiler)) { under = js.js("# < 0", pop()); } else { js.Expression jsIndex = pop(); under = js.js("# >>> 0 !== #", [jsIndex, jsIndex]); } } else if (!node.index.isInteger(compiler)) { checkInt(node.index, '!=='); under = pop(); } if (node.staticChecks != HBoundsCheck.ALWAYS_BELOW_LENGTH) { var index = node.index; use(index); js.Expression jsIndex = pop(); use(node.length); over = new js.Binary(">=", jsIndex, pop()); } assert(over != null || under != null); js.Expression underOver = under == null ? over : over == null ? under : new js.Binary("||", under, over); js.Statement thenBody = new js.Block.empty(); js.Block oldContainer = currentContainer; currentContainer = thenBody; generateThrowWithHelper('ioore', [node.array, node.index]); currentContainer = oldContainer; thenBody = unwrapStatement(thenBody); pushStatement(new js.If.noElse(underOver, thenBody), node); } else { generateThrowWithHelper('ioore', [node.array, node.index]); } } void generateThrowWithHelper(String helperName, argument) { Element helper = backend.findHelper(helperName); registry.registerStaticUse(helper); js.Expression jsHelper = backend.emitter.staticFunctionAccess(helper); List arguments = []; var location; if (argument is List) { location = argument[0]; argument.forEach((instruction) { use(instruction); arguments.add(pop()); }); } else { location = argument; use(argument); arguments.add(pop()); } js.Call value = new js.Call(jsHelper, arguments.toList(growable: false)); value = attachLocation(value, location); // BUG(4906): Using throw/return here adds to the size of the generated code // but it has the advantage of explicitly telling the JS engine that // this code path will terminate abruptly. Needs more work. if (helperName == 'wrapException') { pushStatement(new js.Throw(value)); } else { Element element = work.element; if (element is FunctionElement && element.asyncMarker.isYielding) { // `return <expr>;` is illegal in a sync* or async* function. // To have the the async-translator working, we avoid introducing // `return` nodes. pushStatement(new js.ExpressionStatement(value)); } else { pushStatement(new js.Return(value)); } } } visitThrowExpression(HThrowExpression node) { HInstruction argument = node.inputs[0]; use(argument); Element helper = backend.findHelper("throwExpression"); registry.registerStaticUse(helper); js.Expression jsHelper = backend.emitter.staticFunctionAccess(helper); js.Call value = new js.Call(jsHelper, [pop()]); value = attachLocation(value, argument); push(value, node); } void visitSwitch(HSwitch node) { // Switches are handled using [visitSwitchInfo]. } void visitStatic(HStatic node) { Element element = node.element; assert(element.isFunction || element.isField); if (element.isFunction) { push(backend.emitter.isolateStaticClosureAccess(node.element)); } else { push(backend.emitter.staticFieldAccess(node.element)); } registry.registerStaticUse(element); } void visitLazyStatic(HLazyStatic node) { Element element = node.element; registry.registerStaticUse(element); js.Expression lazyGetter = backend.emitter.isolateLazyInitializerAccess(element); js.Call call = new js.Call(lazyGetter, <js.Expression>[]); push(call, node); } void visitStaticStore(HStaticStore node) { registry.registerStaticUse(node.element); js.Node variable = backend.emitter.staticFieldAccess(node.element); use(node.inputs[0]); push(new js.Assignment(variable, pop()), node); } void visitStringConcat(HStringConcat node) { use(node.left); js.Expression jsLeft = pop(); use(node.right); push(new js.Binary('+', jsLeft, pop()), node); } void visitStringify(HStringify node) { HInstruction input = node.inputs.first; if (input.isString(compiler)) { use(input); } else if (input.isInteger(compiler) || input.isBoolean(compiler)) { // JavaScript's + operator with a string for the left operand will convert // the right operand to a string, and the conversion result is correct. use(input); if (node.usedBy.length == 1 && node.usedBy[0] is HStringConcat && node.usedBy[0].inputs[1] == node) { // The context is already <string> + value. } else { // Force an empty string for the first operand. push(new js.Binary('+', js.string(""), pop()), node); } } else { Element convertToString = backend.getStringInterpolationHelper(); registry.registerStaticUse(convertToString); js.Expression jsHelper = backend.emitter.staticFunctionAccess(convertToString); use(input); push(new js.Call(jsHelper, <js.Expression>[pop()]), node); } } void visitLiteralList(HLiteralList node) { registry.registerInstantiatedClass(compiler.listClass); generateArrayLiteral(node); } void generateArrayLiteral(HLiteralList node) { List<js.Expression> elements = node.inputs.map((HInstruction input) { use(input); return pop(); }).toList(); push(new js.ArrayInitializer(elements), node); } void visitIndex(HIndex node) { use(node.receiver); js.Expression receiver = pop(); use(node.index); push(new js.PropertyAccess(receiver, pop()), node); } void visitIndexAssign(HIndexAssign node) { use(node.receiver); js.Expression receiver = pop(); use(node.index); js.Expression index = pop(); use(node.value); push(new js.Assignment(new js.PropertyAccess(receiver, index), pop()), node); } void checkInt(HInstruction input, String cmp) { use(input); js.Expression left = pop(); use(input); js.Expression or0 = new js.Binary("|", pop(), new js.LiteralNumber("0")); push(new js.Binary(cmp, left, or0)); } void checkBigInt(HInstruction input, String cmp) { use(input); js.Expression left = pop(); use(input); js.Expression right = pop(); // TODO(4984): Deal with infinity and -0.0. push(js.js('Math.floor(#) $cmp #', <js.Expression>[left, right])); } void checkTypeOf(HInstruction input, String cmp, String typeName) { use(input); js.Expression typeOf = new js.Prefix("typeof", pop()); push(new js.Binary(cmp, typeOf, js.string(typeName))); } void checkNum(HInstruction input, String cmp) => checkTypeOf(input, cmp, 'number'); void checkDouble(HInstruction input, String cmp) => checkNum(input, cmp); void checkString(HInstruction input, String cmp) => checkTypeOf(input, cmp, 'string'); void checkBool(HInstruction input, String cmp) => checkTypeOf(input, cmp, 'boolean'); void checkObject(HInstruction input, String cmp) { assert(NullConstantValue.JsNull == 'null'); if (cmp == "===") { checkTypeOf(input, '===', 'object'); js.Expression left = pop(); use(input); js.Expression notNull = new js.Binary("!==", pop(), new js.LiteralNull()); push(new js.Binary("&&", left, notNull)); } else { assert(cmp == "!=="); checkTypeOf(input, '!==', 'object'); js.Expression left = pop(); use(input); js.Expression eqNull = new js.Binary("===", pop(), new js.LiteralNull()); push(new js.Binary("||", left, eqNull)); } } void checkArray(HInstruction input, String cmp) { use(input); js.PropertyAccess constructor = new js.PropertyAccess.field(pop(), 'constructor'); push(new js.Binary(cmp, constructor, new js.VariableUse('Array'))); } void checkFieldExists(HInstruction input, String fieldName) { use(input); js.PropertyAccess field = new js.PropertyAccess.field(pop(), fieldName); // Double negate to boolify the result. push(new js.Prefix('!', new js.Prefix('!', field))); } void checkFieldDoesNotExist(HInstruction input, String fieldName) { use(input); js.PropertyAccess field = new js.PropertyAccess.field(pop(), fieldName); push(new js.Prefix('!', field)); } void checkImmutableArray(HInstruction input) { checkFieldExists(input, 'immutable\$list'); } void checkMutableArray(HInstruction input) { checkFieldDoesNotExist(input, 'immutable\$list'); } void checkExtendableArray(HInstruction input) { checkFieldDoesNotExist(input, 'fixed\$length'); } void checkFixedArray(HInstruction input) { checkFieldExists(input, 'fixed\$length'); } void checkNull(HInstruction input) { use(input); push(new js.Binary('==', pop(), new js.LiteralNull())); } void checkNonNull(HInstruction input) { use(input); push(new js.Binary('!=', pop(), new js.LiteralNull())); } void checkType(HInstruction input, HInstruction interceptor, DartType type, {bool negative: false}) { Element element = type.element; if (element == backend.jsArrayClass) { checkArray(input, negative ? '!==': '==='); return; } else if (element == backend.jsMutableArrayClass) { if (negative) { checkImmutableArray(input); } else { checkMutableArray(input); } return; } else if (element == backend.jsExtendableArrayClass) { if (negative) { checkFixedArray(input); } else { checkExtendableArray(input); } return; } else if (element == backend.jsFixedArrayClass) { if (negative) { checkExtendableArray(input); } else { checkFixedArray(input); } return; } if (interceptor != null) { checkTypeViaProperty(interceptor, type, negative); } else { checkTypeViaProperty(input, type, negative); } } void checkTypeViaProperty(HInstruction input, DartType type, bool negative) { registry.registerIsCheck(type); use(input); js.PropertyAccess field = new js.PropertyAccess.field(pop(), backend.namer.operatorIsType(type)); // We always negate at least once so that the result is boolified. push(new js.Prefix('!', field)); // If the result is not negated, put another '!' in front. if (!negative) push(new js.Prefix('!', pop())); } void checkTypeViaInstanceof( HInstruction input, DartType type, bool negative) { registry.registerIsCheck(type); use(input); js.Expression jsClassReference = backend.emitter.constructorAccess(type.element); push(js.js('# instanceof #', [pop(), jsClassReference])); if (negative) push(new js.Prefix('!', pop())); registry.registerInstantiatedType(type); } void handleNumberOrStringSupertypeCheck(HInstruction input, HInstruction interceptor, DartType type, { bool negative: false }) { assert(!identical(type.element, compiler.listClass) && !Elements.isListSupertype(type.element, compiler) && !Elements.isStringOnlySupertype(type.element, compiler)); String relation = negative ? '!==' : '==='; checkNum(input, relation); js.Expression numberTest = pop(); checkString(input, relation); js.Expression stringTest = pop(); checkObject(input, relation); js.Expression objectTest = pop(); checkType(input, interceptor, type, negative: negative); String combiner = negative ? '&&' : '||'; String combiner2 = negative ? '||' : '&&'; push(new js.Binary(combiner, new js.Binary(combiner, numberTest, stringTest), new js.Binary(combiner2, objectTest, pop()))); } void handleStringSupertypeCheck(HInstruction input, HInstruction interceptor, DartType type, { bool negative: false }) { assert(!identical(type.element, compiler.listClass) && !Elements.isListSupertype(type.element, compiler) && !Elements.isNumberOrStringSupertype(type.element, compiler)); String relation = negative ? '!==' : '==='; checkString(input, relation); js.Expression stringTest = pop(); checkObject(input, relation); js.Expression objectTest = pop(); checkType(input, interceptor, type, negative: negative); String combiner = negative ? '||' : '&&'; push(new js.Binary(negative ? '&&' : '||', stringTest, new js.Binary(combiner, objectTest, pop()))); } void handleListOrSupertypeCheck(HInstruction input, HInstruction interceptor, DartType type, { bool negative: false }) { assert(!identical(type.element, compiler.stringClass) && !Elements.isStringOnlySupertype(type.element, compiler) && !Elements.isNumberOrStringSupertype(type.element, compiler)); String relation = negative ? '!==' : '==='; checkObject(input, relation); js.Expression objectTest = pop(); checkArray(input, relation); js.Expression arrayTest = pop(); checkType(input, interceptor, type, negative: negative); String combiner = negative ? '&&' : '||'; push(new js.Binary(negative ? '||' : '&&', objectTest, new js.Binary(combiner, arrayTest, pop()))); } void visitIs(HIs node) { emitIs(node, "==="); } void visitIsViaInterceptor(HIsViaInterceptor node) { emitIsViaInterceptor(node, false); } void emitIs(HIs node, String relation) { DartType type = node.typeExpression; registry.registerIsCheck(type); HInstruction input = node.expression; // If this is changed to single == there are several places below that must // be changed to match. assert(relation == '===' || relation == '!=='); bool negative = relation == '!=='; if (node.isVariableCheck || node.isCompoundCheck) { use(node.checkCall); if (negative) push(new js.Prefix('!', pop())); } else { assert(node.isRawCheck); HInstruction interceptor = node.interceptor; LibraryElement coreLibrary = compiler.coreLibrary; ClassElement objectClass = compiler.objectClass; Element element = type.element; if (element == compiler.nullClass) { if (negative) { checkNonNull(input); } else { checkNull(input); } } else if (identical(element, objectClass) || type.treatAsDynamic) { // The constant folder also does this optimization, but we make // it safe by assuming it may have not run. push(newLiteralBool(!negative), node); } else if (element == compiler.stringClass) { checkString(input, relation); attachLocationToLast(node); } else if (element == compiler.doubleClass) { checkDouble(input, relation); attachLocationToLast(node); } else if (element == compiler.numClass) { checkNum(input, relation); attachLocationToLast(node); } else if (element == compiler.boolClass) { checkBool(input, relation); attachLocationToLast(node); } else if (element == compiler.intClass) { // The is check in the code tells us that it might not be an // int. So we do a typeof first to avoid possible // deoptimizations on the JS engine due to the Math.floor check. checkNum(input, relation); js.Expression numTest = pop(); checkBigInt(input, relation); push(new js.Binary(negative ? '||' : '&&', numTest, pop()), node); } else if (node.useInstanceOf) { assert(interceptor == null); checkTypeViaInstanceof(input, type, negative); attachLocationToLast(node); } else if (Elements.isNumberOrStringSupertype(element, compiler)) { handleNumberOrStringSupertypeCheck( input, interceptor, type, negative: negative); attachLocationToLast(node); } else if (Elements.isStringOnlySupertype(element, compiler)) { handleStringSupertypeCheck( input, interceptor, type, negative: negative); attachLocationToLast(node); } else if (identical(element, compiler.listClass) || Elements.isListSupertype(element, compiler)) { handleListOrSupertypeCheck( input, interceptor, type, negative: negative); attachLocationToLast(node); } else if (type.isFunctionType) { checkType(input, interceptor, type, negative: negative); attachLocationToLast(node); } else if ((input.canBePrimitive(compiler) && !input.canBePrimitiveArray(compiler)) || input.canBeNull()) { checkObject(input, relation); js.Expression objectTest = pop(); checkType(input, interceptor, type, negative: negative); push(new js.Binary(negative ? '||' : '&&', objectTest, pop()), node); } else { checkType(input, interceptor, type, negative: negative); attachLocationToLast(node); } } } void emitIsViaInterceptor(HIsViaInterceptor node, bool negative) { checkTypeViaProperty(node.interceptor, node.typeExpression, negative); attachLocationToLast(node); } js.Expression generateReceiverOrArgumentTypeTest( HInstruction input, TypeMask checkedType) { ClassWorld classWorld = compiler.world; TypeMask inputType = input.instructionType; // Figure out if it is beneficial to turn this into a null check. // V8 generally prefers 'typeof' checks, but for integers and // indexable primitives we cannot compile this test into a single // typeof check so the null check is cheaper. bool isIntCheck = checkedType.containsOnlyInt(classWorld); bool turnIntoNumCheck = isIntCheck && input.isIntegerOrNull(compiler); bool turnIntoNullCheck = !turnIntoNumCheck && (checkedType.nullable() == inputType) && (isIntCheck || checkedType.satisfies(backend.jsIndexableClass, classWorld)); if (turnIntoNullCheck) { use(input); return new js.Binary("==", pop(), new js.LiteralNull()); } else if (isIntCheck && !turnIntoNumCheck) { // input is !int checkBigInt(input, '!=='); return pop(); } else if (turnIntoNumCheck || checkedType.containsOnlyNum(classWorld)) { // input is !num checkNum(input, '!=='); return pop(); } else if (checkedType.containsOnlyBool(classWorld)) { // input is !bool checkBool(input, '!=='); return pop(); } else if (checkedType.containsOnlyString(classWorld)) { // input is !string checkString(input, '!=='); return pop(); } compiler.internalError(input, 'Unexpected check.'); return null; } void visitTypeConversion(HTypeConversion node) { if (node.isArgumentTypeCheck || node.isReceiverTypeCheck) { ClassWorld classWorld = compiler.world; // An int check if the input is not int or null, is not // sufficient for doing an argument or receiver check. assert(compiler.trustTypeAnnotations || !node.checkedType.containsOnlyInt(classWorld) || node.checkedInput.isIntegerOrNull(compiler)); js.Expression test = generateReceiverOrArgumentTypeTest( node.checkedInput, node.checkedType); js.Block oldContainer = currentContainer; js.Statement body = new js.Block.empty(); currentContainer = body; if (node.isArgumentTypeCheck) { generateThrowWithHelper('iae', node.checkedInput); } else if (node.isReceiverTypeCheck) { use(node.checkedInput); String methodName = backend.namer.invocationName(node.receiverTypeCheckSelector); js.Expression call = js.propertyCall(pop(), methodName, []); pushStatement(new js.Return(call)); } currentContainer = oldContainer; body = unwrapStatement(body); pushStatement(new js.If.noElse(test, body), node); return; } assert(node.isCheckedModeCheck || node.isCastTypeCheck); DartType type = node.typeExpression; assert(type.kind != TypeKind.TYPEDEF); if (type.isFunctionType) { // TODO(5022): We currently generate $isFunction checks for // function types. registry.registerIsCheck(compiler.functionClass.rawType); } registry.registerIsCheck(type); CheckedModeHelper helper; if (node.isBooleanConversionCheck) { helper = const CheckedModeHelper('boolConversionCheck'); } else { helper = backend.getCheckedModeHelper(type, typeCast: node.isCastTypeCheck); } if (helper == null) { assert(type.isFunctionType); use(node.inputs[0]); } else { push(helper.generateCall(this, node)); } } void visitTypeKnown(HTypeKnown node) { // [HTypeKnown] instructions are removed before generating code. assert(false); } void visitFunctionType(HFunctionType node) { FunctionType type = node.dartType; int inputCount = 0; use(node.inputs[inputCount++]); js.Expression returnType = pop(); List<js.Expression> parameterTypes = <js.Expression>[]; for (var _ in type.parameterTypes) { use(node.inputs[inputCount++]); parameterTypes.add(pop()); } List<js.Expression> optionalParameterTypes = <js.Expression>[]; for (var _ in type.optionalParameterTypes) { use(node.inputs[inputCount++]); optionalParameterTypes.add(pop()); } List<js.Property> namedParameters = <js.Property>[]; for (var _ in type.namedParameters) { use(node.inputs[inputCount++]); js.Expression name = pop(); use(node.inputs[inputCount++]); namedParameters.add(new js.Property(name, pop())); } if (namedParameters.isEmpty) { var arguments = [returnType]; if (!parameterTypes.isEmpty || !optionalParameterTypes.isEmpty) { arguments.add(new js.ArrayInitializer(parameterTypes)); } if (!optionalParameterTypes.isEmpty) { arguments.add(new js.ArrayInitializer(optionalParameterTypes)); } push(js.js('#(#)', [accessHelper('buildFunctionType'), arguments])); } else { var arguments = [ returnType, new js.ArrayInitializer(parameterTypes), new js.ObjectInitializer(namedParameters)]; push(js.js('#(#)', [accessHelper('buildNamedFunctionType'), arguments])); } } void visitReadTypeVariable(HReadTypeVariable node) { TypeVariableElement element = node.dartType.element; Element helperElement = backend.findHelper('convertRtiToRuntimeType'); registry.registerStaticUse(helperElement); use(node.inputs[0]); if (node.hasReceiver) { if (backend.isInterceptorClass(element.enclosingClass)) { int index = RuntimeTypes.getTypeVariableIndex(element); js.Expression receiver = pop(); js.Expression helper = backend.emitter .staticFunctionAccess(helperElement); push(js.js(r'#(#.$builtinTypeInfo && #.$builtinTypeInfo[#])', [helper, receiver, receiver, js.js.number(index)])); } else { backend.emitter.registerReadTypeVariable(element); push(js.js('#.#()', [pop(), backend.namer.nameForReadTypeVariable(element)])); } } else { push(js.js('#(#)', [ backend.emitter.staticFunctionAccess( backend.findHelper('convertRtiToRuntimeType')), pop()])); } } void visitInterfaceType(HInterfaceType node) { List<js.Expression> typeArguments = <js.Expression>[]; for (HInstruction type in node.inputs) { use(type); typeArguments.add(pop()); } ClassElement cls = node.dartType.element; var arguments = [backend.emitter.typeAccess(cls)]; if (!typeArguments.isEmpty) { arguments.add(new js.ArrayInitializer(typeArguments)); } push(js.js('#(#)', [accessHelper('buildInterfaceType'), arguments])); } void visitVoidType(HVoidType node) { push(js.js('#()', accessHelper('getVoidRuntimeType'))); } void visitDynamicType(HDynamicType node) { push(js.js('#()', accessHelper('getDynamicRuntimeType'))); } js.PropertyAccess accessHelper(String name) { Element helper = backend.findHelper(name); if (helper == null) { // For mocked-up tests. return js.js('(void 0).$name'); } registry.registerStaticUse(helper); return backend.emitter.staticFunctionAccess(helper); } }