public static WarningAnnotation<String> forVariable(Variable var) { return Roles.VARIABLE.create(var.getName()); } }
private static ResolveResult resolveTypeFromVariable(final Variable variable) { if (variable == null) { return null; } TypeReference type = variable.getType(); if (type == null) { type = variable.isParameter() ? variable.getOriginalParameter().getParameterType() : variable.getOriginalVariable().getVariableType(); } if (type != null) { return new ResolveResult(type); } return null; }
private boolean shouldInferVariableType(final Variable variable) { final VariableDefinition variableDefinition = variable.getOriginalVariable(); if (variable.isGenerated() || variable.isLambdaParameter()) { return true; } if (variable.isParameter()) { final ParameterDefinition parameter = variable.getOriginalParameter(); if (parameter == _context.getCurrentMethod().getBody().getThisParameter()) { return false; } final TypeReference parameterType = parameter.getParameterType(); return !_preserveMetadataGenericTypes && (parameterType.isGenericType() || MetadataHelper.isRawType(parameterType)); } //noinspection RedundantIfStatement if (variableDefinition != null && variableDefinition.isFromMetadata() && (variableDefinition.getVariableType().isGenericType() ? _preserveMetadataGenericTypes : _preserveMetadataTypes)) { return false; } return true; }
private boolean notFromMetadata(final Variable variable) { return variable.isGenerated() || !variable.isParameter() && !variable.getOriginalVariable().isFromMetadata(); }
public static TypeReference getExpressionType(Expression expr) { TypeReference exprType = expr.getInferredType(); if (expr.getOperand() instanceof Variable) { Variable var = (Variable) expr.getOperand(); exprType = var.getType(); if (var.getOriginalParameter() != null) exprType = var.getOriginalParameter().getParameterType(); } return exprType; }
final Variable variable = (Variable) operand; if (variable.isParameter()) { methodParameters.add(variable); unmatchedParameters.remove(variable.getOriginalParameter()); final Variable v = new Variable(); v.setName(p.getName()); v.setOriginalParameter(p); v.setType(p.getParameterType()); orderedParameters.add(v); declaration.setName(p.getName()); TypeReference variableType = v.getType(); final VariableDeclarationStatement declaration = new VariableDeclarationStatement(type, v.getName(), Expression.MYSTERY_OFFSET);
final Variable variable = new Variable(); variable.setName("this"); variable.setType(context.getCurrentMethod().getDeclaringType()); variable.setOriginalParameter(context.getCurrentMethod().getBody().getThisParameter()); final Variable variable = new Variable(); variable.setName(p.getName()); variable.setType(p.getParameterType()); variable.setOriginalParameter(p); variable.setLambdaParameter(true); final Variable v = lambdaParameters.get(0); v.setOriginalParameter(null); v.setGenerated(true); final Variable oldVariable = (Variable) operand; if (oldVariable.isParameter() && oldVariable.getOriginalParameter().getMethod() == resolvedMethod) { final Variable newVariable = parameterMap[oldVariable.getOriginalParameter().getSlot()];
final Variable variable = new Variable(); variable.setName( StringUtilities.isNullOrEmpty(parameter.getName()) ? "p" + parameter.getPosition() : parameter.getName() ); variable.setType(parameter.getParameterType()); variable.setOriginalParameter(parameter); variable.setOriginalVariable(vDef); if (variableType.isPrimitive() || parameterVariable.variable.getType().isPrimitive()) { useParameter = variableType.getSimpleType() == parameterVariable.variable.getType().getSimpleType(); useParameter = MetadataHelper.isSameType(variableType, parameterVariable.variable.getType()); final Variable variable = new Variable(); variable.setName(vDef.getName()); variable.setName(format("var_%1$d_%2$02X", slot, b.offset)); variable.setType(variableType); variable.setOriginalVariable(new VariableDefinition(slot, variable.getName(), method, variable.getType())); variable.setOriginalVariable(vDef); variable.setGenerated(false);
nv.addExistingName(p.getName()); if (v.isGenerated()) { nv.addExistingName(v.getName()); final VariableDefinition originalVariable = v.getOriginalVariable(); v.setName(null); v.setName(nv.getAlternativeName(varName)); v.setName(null); if (!p.getOriginalParameter().hasName()) { p.setName(nv.generateNameForVariable(p, methodBody)); final boolean generateName = StringUtilities.isNullOrEmpty(varDef.getName()) || varDef.isGenerated() || !varDef.isParameter() && !varDef.getOriginalVariable().isFromMetadata(); varDef.setName(nv.generateNameForVariable(varDef, methodBody));
!variable.get().isParameter() && count(storeCounts, variable.get()) == 1 && canPerformCopyPropagation(copiedExpression.get(), variable.get())) { final Variable newVariable = new Variable(); newVariable.setGenerated(true); newVariable.setName(format("%s_cp_%d", variable.get().getName(), j));
final VariableDefinition vDef) { final Variable variable = new Variable(); variable.setType(vDef.getVariableType()); variable.setName( StringUtilities.isNullOrEmpty(vDef.getName()) ? "var_" + slot : vDef.getName() variable.setName("var_" + slot); variable.setType(variableType); break; if (variable.getType() == null) { variable.setType(BuiltinTypes.Object); variable.setOriginalVariable(new VariableDefinition(slot, variable.getName(), method, variable.getType())); variable.setOriginalVariable(vDef); variable.setGenerated(false);
final Object operand = e.getOperand(); if (operand instanceof Variable && !((Variable) operand).isParameter()) { allVariables.add((Variable) operand); output.writeDefinition(variable.getName(), variable); final TypeReference type = variable.getType(); if (variable.isGenerated()) { output.write(" [generated]");
@Override public boolean matches(final INode other, final Match match) { if (other instanceof IdentifierExpression) { final IdentifierExpression identifier = (IdentifierExpression) other; final Variable variable = identifier.getUserData(Keys.VARIABLE); if (variable != null && variable.isParameter() && variable.getOriginalParameter().getPosition() == _parameterPosition) { if (_groupName != null) { match.add(_groupName, identifier); } return true; } } return false; } }
final Variable exceptionVariable = new Variable(); exceptionVariable.setName(format("ex_%1$02X", handlerStart)); exceptionVariable.setGenerated(true); final Variable exceptionTemp = new Variable(); exceptionTemp.setName(format("ex_%1$02X", handlerStart)); exceptionTemp.setGenerated(true);
private Object getCurrentLocalReference() { final AstNode node = nodeStack.peek(); Variable variable = node.getUserData(Keys.VARIABLE); if (variable == null && node instanceof Identifier && node.getParent() != null) { variable = node.getParent().getUserData(Keys.VARIABLE); } if (variable != null) { if (variable.isParameter()) { return variable.getOriginalParameter(); } return variable.getOriginalVariable(); } return null; }
private static boolean shouldResetVariableType( final Variable variable, final boolean preserveTypesFromMetadata, final boolean preserveGenericTypesFromMetadata) { if (variable.isGenerated() || variable.isLambdaParameter()) { return true; } final VariableDefinition variableDefinition = variable.getOriginalVariable(); //noinspection SimplifiableIfStatement if (variableDefinition != null && variableDefinition.isFromMetadata() && (variableDefinition.getVariableType().isGenericType() ? preserveGenericTypesFromMetadata : preserveTypesFromMetadata)) { return false; } return variableDefinition != null && variableDefinition.getVariableType() == BuiltinTypes.Integer || variableDefinition != null && !variableDefinition.isTypeKnown(); }
TypeReference inferredType = null; if (variable.isLambdaParameter()) { inferredType = _inferredVariableTypes.get(variable); inferredType = variable.getType(); variable.setType(inferredType); _inferredVariableTypes.put(variable, inferredType);
final Variable exceptionTemp = new Variable(); exceptionTemp.setName(format("ex_%1$02X", handlerStart)); exceptionTemp.setGenerated(true); exceptionTemp.setType(catchBlock.getExceptionType()); final Variable exceptionVariable = new Variable(); exceptionVariable.setName(format("ex_%1$02X", handlerStart)); exceptionVariable.setGenerated(true);
final boolean canPerformCopyPropagation(final Expression expr, final Variable copyVariable) { switch (expr.getCode()) { case Load: { final Variable v = (Variable) expr.getOperand(); if (v.isParameter()) { // // Parameters can be copied only if they aren't assigned to. // return count(storeCounts, v) == 0; } // // Variables can be copied only if both the variable and the target copy variable are generated, // and if the variable has only a single assignment. // return v.isGenerated() && copyVariable.isGenerated() && count(storeCounts, v) == 1; } default: { return false; } } }
private static Nullness get(Map<Variable, Nullness> map, Variable v) { Nullness nullness = map.get(v); if(nullness != null) return nullness; ParameterDefinition pd = v.getOriginalParameter(); if(pd != null) { return Nullness.UNKNOWN_AT_ENTRY; } return null; }