@Override public void visit(InvokeInstruction insn) { Expr[] exprArgs = new Expr[insn.getMethod().getParameterTypes().length]; for (int i = 0; i < insn.getArguments().size(); ++i) { exprArgs[i] = Expr.var(insn.getArguments().get(i).getIndex()); } InvocationExpr invocationExpr; if (insn.getInstance() != null) { if (insn.getType() == InvocationType.VIRTUAL) { invocationExpr = Expr.invoke(insn.getMethod(), Expr.var(insn.getInstance().getIndex()), exprArgs); } else { invocationExpr = Expr.invokeSpecial(insn.getMethod(), Expr.var(insn.getInstance().getIndex()), exprArgs); } } else { invocationExpr = Expr.invokeStatic(insn.getMethod(), exprArgs); } AssignmentStatement stmt; if (insn.getReceiver() != null) { stmt = Statement.assign(Expr.var(insn.getReceiver().getIndex()), invocationExpr); stmt.getDebugNames().addAll(insn.getReceiver().getDebugNames()); } else { stmt = Statement.assign(null, invocationExpr); } stmt.setLocation(currentLocation); stmt.setAsync(async); async = false; statements.add(stmt); }
@Override public void visitAssignmentStatement(AssignmentStatement assignmentStatement) { incr(); space(); System.out.println("Assignment: " + assignmentStatement.getLocalReference()); assignmentStatement.getExpressionStatement().accept(this); decr(); }
@Override public void visit(AssignInstruction insn) { AssignmentStatement stmt = Statement.assign( Expr.var(insn.getReceiver().getIndex()), Expr.var(insn.getAssignee().getIndex())); stmt.getDebugNames().addAll(insn.getReceiver().getDebugNames()); stmt.setLocation(currentLocation); statements.add(stmt); }
@Override public void visit(PutElementInstruction insn) { AssignmentStatement stmt = Statement.assign( Expr.subscript( Expr.var(insn.getArray().getIndex()), Expr.var(insn.getIndex().getIndex())), Expr.var(insn.getValue().getIndex())); stmt.setLocation(currentLocation); statements.add(stmt); }
@Override public void visit(PutFieldInstruction insn) { Expr right = Expr.var(insn.getValue().getIndex()); Expr left; if (insn.getInstance() != null) { left = Expr.qualify(Expr.var(insn.getInstance().getIndex()), insn.getField()); } else { left = Expr.qualify(null, insn.getField()); } AssignmentStatement stmt = Statement.assign(left, right); stmt.setLocation(currentLocation); statements.add(stmt); }
@Override public void visit(VariableExpr expr) { int index = expr.getIndex(); resultExpr = expr; if (readFrequencies[index] != 1 || preservedVars[index]) { return; } if (resultSequence.isEmpty()) { return; } Statement last = resultSequence.get(resultSequence.size() - 1); if (!(last instanceof AssignmentStatement)) { return; } AssignmentStatement assignment = (AssignmentStatement) last; if (assignment.isAsync()) { return; } if (!(assignment.getLeftValue() instanceof VariableExpr)) { return; } VariableExpr var = (VariableExpr) assignment.getLeftValue(); if (var.getLocation() != null && assignment.getLocation() != null && !assignment.getLocation().equals(var.getLocation())) { return; } if (var.getIndex() == index) { resultSequence.remove(resultSequence.size() - 1); assignment.getRightValue().setLocation(assignment.getLocation()); assignment.getRightValue().acceptVisitor(this); } }
@Override public void visit(GetFieldInstruction insn) { if (insn.getInstance() != null) { AssignmentStatement stmt = Statement.assign( Expr.var(insn.getReceiver().getIndex()), Expr.qualify(Expr.var(insn.getInstance().getIndex()), insn.getField())); stmt.setLocation(currentLocation); statements.add(stmt); } else { Expr fieldExpr = Expr.qualify(null, insn.getField()); AssignmentStatement stmt = Statement.assign(Expr.var(insn.getReceiver().getIndex()), fieldExpr); stmt.setLocation(currentLocation); statements.add(stmt); } }
@Override public void visitAssignmentStatement(AssignmentStatement assignmentStatement) { LocalReference localReference = assignmentStatement.getLocalReference(); String referenceName = localReference.getName(); if (!localReference.isModuleState()) { if (!stack.isEmpty()) { assignmentStatement.setLocalReference( context().referenceTableStack.peek().get(referenceName)); } if (assignmentStatement.isDeclaring()) { locallyDeclared(referenceName); } } else { locallyDeclared(referenceName); } locallyAssigned(referenceName); assignmentStatement.getExpressionStatement().accept(this); if (assignmentStatement.getExpressionStatement() instanceof ClosureReference) { ClosureReference closure = (ClosureReference) assignmentStatement.getExpressionStatement(); GoloFunction target = closure.getTarget(); if (target.getSyntheticParameterNames().contains(referenceName)) { target.removeSyntheticParameter(referenceName); target.setSyntheticSelfName(referenceName); } } }
@Override public void visit(AssignmentStatement statement) { if (statement.getLeftValue() == null) { statement.getRightValue().acceptVisitor(this); if (resultExpr instanceof InvocationExpr && tryApplyConstructor((InvocationExpr) resultExpr)) { resultStmt = new SequentialStatement(); } else { statement.setRightValue(resultExpr); resultStmt = statement; } } else { statement.getRightValue().acceptVisitor(this); Expr right = resultExpr; Expr left = statement.getLeftValue(); if (!(statement.getLeftValue() instanceof VariableExpr)) { statement.getLeftValue().acceptVisitor(this); left = resultExpr; } statement.setLeftValue(left); statement.setRightValue(right); resultStmt = statement; } }
private boolean tryApplyConstructor(InvocationExpr expr) { if (!expr.getMethod().getName().equals("<init>")) { return false; } if (resultSequence == null || resultSequence.isEmpty()) { return false; } Statement last = resultSequence.get(resultSequence.size() - 1); if (!(last instanceof AssignmentStatement)) { return false; } AssignmentStatement assignment = (AssignmentStatement) last; if (!(assignment.getLeftValue() instanceof VariableExpr)) { return false; } VariableExpr var = (VariableExpr) assignment.getLeftValue(); if (!(expr.getArguments().get(0) instanceof VariableExpr)) { return false; } VariableExpr target = (VariableExpr) expr.getArguments().get(0); if (target.getIndex() != var.getIndex()) { return false; } if (!(assignment.getRightValue() instanceof NewExpr)) { return false; } NewExpr constructed = (NewExpr) assignment.getRightValue(); if (!constructed.getConstructedClass().equals(expr.getMethod().getClassName())) { return false; } Expr[] args = expr.getArguments().toArray(new Expr[0]); args = Arrays.copyOfRange(args, 1, args.length); InvocationExpr constructrExpr = Expr.constructObject(expr.getMethod(), args); constructrExpr.setLocation(expr.getLocation()); assignment.setRightValue(constructrExpr); readFrequencies[var.getIndex()]--; return true; }
public void visit(AssignmentStatement node) { visit(node.getLValue()); visit(node.getExpression()); }
private void assign(Expr source, Variable target) { AssignmentStatement stmt = Statement.assign(Expr.var(target.getIndex()), source); stmt.setLocation(currentLocation); stmt.getDebugNames().addAll(target.getDebugNames()); statements.add(stmt); }
private void resolveStatement( CreateProcedureCommand command, Statement statement, GroupContext externalGroups, GroupSymbol variables, TempMetadataAdapter metadata) throws QueryResolverException, QueryMetadataException, TeiidComponentException { LogManager.logTrace( org.teiid.logging.LogConstants.CTX_QUERY_RESOLVER, new Object[] {"Resolving statement", statement}); // $NON-NLS-1$ switch (statement.getType()) { case Statement.TYPE_IF: IfStatement ifStmt = (IfStatement) statement; Criteria ifCrit = ifStmt.getCondition(); for (SubqueryContainer container : ValueIteratorProviderCollectorVisitor.getValueIteratorProviders(ifCrit)) { resolveEmbeddedCommand(metadata, externalGroups, container.getCommand()); } ResolverVisitor.resolveLanguageObject(ifCrit, null, externalGroups, metadata); resolveBlock(command, ifStmt.getIfBlock(), externalGroups, metadata); if (ifStmt.hasElseBlock()) { resolveBlock(command, ifStmt.getElseBlock(), externalGroups, metadata); } break; case Statement.TYPE_COMMAND: CommandStatement cmdStmt = (CommandStatement) statement; Command subCommand = cmdStmt.getCommand(); TempMetadataStore discoveredMetadata = resolveEmbeddedCommand(metadata, externalGroups, subCommand); if (subCommand instanceof StoredProcedure) { StoredProcedure sp = (StoredProcedure) subCommand; for (SPParameter param : sp.getParameters()) { switch (param.getParameterType()) { case ParameterInfo.OUT: case ParameterInfo.RETURN_VALUE: if (param.getExpression() != null && !isAssignable(metadata, param)) { throw new QueryResolverException( QueryPlugin.Event.TEIID30121, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30121, param.getExpression())); } sp.setCallableStatement(true); break; case ParameterInfo.INOUT: if (!isAssignable(metadata, param)) { continue; } sp.setCallableStatement(true); break; } } } if (discoveredMetadata != null) { metadata.getMetadataStore().getData().putAll(discoveredMetadata.getData()); } // dynamic commands need to be updated as to their implicitly expected projected symbols if (subCommand instanceof DynamicCommand) { DynamicCommand dynCommand = (DynamicCommand) subCommand; if (dynCommand.getIntoGroup() == null && !dynCommand.isAsClauseSet()) { if ((command.getResultSetColumns() != null && command.getResultSetColumns().isEmpty()) || !cmdStmt.isReturnable() || command.getResultSetColumns() == null) { // we're not interested in the resultset dynCommand.setAsColumns(Collections.EMPTY_LIST); } else { // should match the procedure dynCommand.setAsColumns(command.getResultSetColumns()); } } } if (command.getResultSetColumns() == null && cmdStmt.isReturnable() && subCommand.returnsResultSet() && subCommand.getResultSetColumns() != null && !subCommand.getResultSetColumns().isEmpty()) { command.setResultSetColumns(subCommand.getResultSetColumns()); if (command.getProjectedSymbols().isEmpty()) { command.setProjectedSymbols(subCommand.getResultSetColumns()); } } break; case Statement.TYPE_ERROR: case Statement.TYPE_ASSIGNMENT: case Statement.TYPE_DECLARE: case Statement.TYPE_RETURN: ExpressionStatement exprStmt = (ExpressionStatement) statement; // first resolve the value. this ensures the value cannot use the variable being defined if (exprStmt.getExpression() != null) { Expression expr = exprStmt.getExpression(); for (SubqueryContainer container : ValueIteratorProviderCollectorVisitor.getValueIteratorProviders(expr)) { resolveEmbeddedCommand(metadata, externalGroups, container.getCommand()); } ResolverVisitor.resolveLanguageObject(expr, null, externalGroups, metadata); } // second resolve the variable switch (statement.getType()) { case Statement.TYPE_DECLARE: collectDeclareVariable( (DeclareStatement) statement, variables, metadata, externalGroups); break; case Statement.TYPE_ASSIGNMENT: AssignmentStatement assStmt = (AssignmentStatement) statement; ResolverVisitor.resolveLanguageObject( assStmt.getVariable(), null, externalGroups, metadata); if (!metadata.elementSupports( assStmt.getVariable().getMetadataID(), SupportConstants.Element.UPDATE)) { throw new QueryResolverException( QueryPlugin.Event.TEIID30121, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30121, assStmt.getVariable())); } // don't allow variable assignments to be external assStmt.getVariable().setIsExternalReference(false); break; case Statement.TYPE_RETURN: ReturnStatement rs = (ReturnStatement) statement; if (rs.getExpression() != null) { if (command.getReturnVariable() == null) { throw new QueryResolverException( QueryPlugin.Event.TEIID31125, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID31125, rs)); } rs.setVariable(command.getReturnVariable().clone()); } // else - we don't currently require the use of return for backwards compatibility break; } // third ensure the type matches if (exprStmt.getExpression() != null) { Class<?> varType = exprStmt.getExpectedType(); Class<?> exprType = exprStmt.getExpression().getType(); if (exprType == null) { throw new QueryResolverException( QueryPlugin.Event.TEIID30123, QueryPlugin.Util.gs(QueryPlugin.Event.TEIID30123)); } String varTypeName = DataTypeManager.getDataTypeName(varType); exprStmt.setExpression( ResolverUtil.convertExpression(exprStmt.getExpression(), varTypeName, metadata)); if (statement.getType() == Statement.TYPE_ERROR) { ResolverVisitor.checkException(exprStmt.getExpression()); } } break; case Statement.TYPE_WHILE: WhileStatement whileStmt = (WhileStatement) statement; Criteria whileCrit = whileStmt.getCondition(); for (SubqueryContainer container : ValueIteratorProviderCollectorVisitor.getValueIteratorProviders(whileCrit)) { resolveEmbeddedCommand(metadata, externalGroups, container.getCommand()); } ResolverVisitor.resolveLanguageObject(whileCrit, null, externalGroups, metadata); resolveBlock(command, whileStmt.getBlock(), externalGroups, metadata); break; case Statement.TYPE_LOOP: LoopStatement loopStmt = (LoopStatement) statement; String groupName = loopStmt.getCursorName(); isValidGroup(metadata, groupName); Command cmd = loopStmt.getCommand(); resolveEmbeddedCommand(metadata, externalGroups, cmd); List<Expression> symbols = cmd.getProjectedSymbols(); // add the loop cursor group into its own context TempMetadataStore store = metadata.getMetadataStore().clone(); metadata = new TempMetadataAdapter(metadata.getMetadata(), store); externalGroups = new GroupContext(externalGroups, null); ProcedureContainerResolver.addScalarGroup(groupName, store, externalGroups, symbols, false); resolveBlock(command, loopStmt.getBlock(), externalGroups, metadata); break; case Statement.TYPE_COMPOUND: resolveBlock(command, (Block) statement, externalGroups, metadata); break; } }