| /******************************************************************************* |
| * Copyright (c) 2000, 2014 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| * Mickael Istria (Red Hat Inc.) - 426209 Java 6 + Warnings cleanup |
| *******************************************************************************/ |
| package org.eclipse.wst.jsdt.internal.corext.refactoring.typeconstraints; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.HashSet; |
| import java.util.LinkedHashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| import org.eclipse.core.runtime.Assert; |
| import org.eclipse.wst.jsdt.core.dom.ArrayCreation; |
| import org.eclipse.wst.jsdt.core.dom.ArrayInitializer; |
| import org.eclipse.wst.jsdt.core.dom.Assignment; |
| import org.eclipse.wst.jsdt.core.dom.CatchClause; |
| import org.eclipse.wst.jsdt.core.dom.ClassInstanceCreation; |
| import org.eclipse.wst.jsdt.core.dom.ConditionalExpression; |
| import org.eclipse.wst.jsdt.core.dom.ConstructorInvocation; |
| import org.eclipse.wst.jsdt.core.dom.Expression; |
| import org.eclipse.wst.jsdt.core.dom.FieldAccess; |
| import org.eclipse.wst.jsdt.core.dom.FieldDeclaration; |
| import org.eclipse.wst.jsdt.core.dom.FunctionDeclaration; |
| import org.eclipse.wst.jsdt.core.dom.FunctionInvocation; |
| import org.eclipse.wst.jsdt.core.dom.IBinding; |
| import org.eclipse.wst.jsdt.core.dom.IFunctionBinding; |
| import org.eclipse.wst.jsdt.core.dom.ITypeBinding; |
| import org.eclipse.wst.jsdt.core.dom.IVariableBinding; |
| import org.eclipse.wst.jsdt.core.dom.InstanceofExpression; |
| import org.eclipse.wst.jsdt.core.dom.Name; |
| import org.eclipse.wst.jsdt.core.dom.ParenthesizedExpression; |
| import org.eclipse.wst.jsdt.core.dom.QualifiedName; |
| import org.eclipse.wst.jsdt.core.dom.ReturnStatement; |
| import org.eclipse.wst.jsdt.core.dom.SimpleName; |
| import org.eclipse.wst.jsdt.core.dom.SingleVariableDeclaration; |
| import org.eclipse.wst.jsdt.core.dom.SuperConstructorInvocation; |
| import org.eclipse.wst.jsdt.core.dom.SuperFieldAccess; |
| import org.eclipse.wst.jsdt.core.dom.SuperMethodInvocation; |
| import org.eclipse.wst.jsdt.core.dom.ThisExpression; |
| import org.eclipse.wst.jsdt.core.dom.Type; |
| import org.eclipse.wst.jsdt.core.dom.VariableDeclaration; |
| import org.eclipse.wst.jsdt.core.dom.VariableDeclarationExpression; |
| import org.eclipse.wst.jsdt.core.dom.VariableDeclarationFragment; |
| import org.eclipse.wst.jsdt.core.dom.VariableDeclarationStatement; |
| import org.eclipse.wst.jsdt.internal.corext.dom.ASTNodes; |
| import org.eclipse.wst.jsdt.internal.corext.dom.Bindings; |
| import org.eclipse.wst.jsdt.internal.corext.refactoring.rename.MethodChecks; |
| |
| /** |
| * Default implementation of the creator. Creates all or nearly all constraints for program constructs. |
| * Subclasses can provide additional checks to avoid creating constraints that are not useful for their purposes. |
| */ |
| public class FullConstraintCreator extends ConstraintCreator{ |
| |
| private final IConstraintVariableFactory fConstraintVariableFactory; |
| private final ITypeConstraintFactory fTypeConstraintFactory; |
| private IContext fContext; |
| |
| public FullConstraintCreator(){ |
| this(new ConstraintVariableFactory(), new TypeConstraintFactory()); |
| } |
| |
| public FullConstraintCreator(IConstraintVariableFactory cFactory, |
| ITypeConstraintFactory tFactory) { |
| Assert.isTrue(cFactory != null); |
| fConstraintVariableFactory= cFactory; |
| fTypeConstraintFactory= tFactory; |
| fContext= new NullContext(); |
| } |
| |
| public IContext getContext() { |
| return fContext; |
| } |
| |
| public void setContext(IContext context) { |
| fContext= context; |
| } |
| |
| public ITypeConstraintFactory getConstraintFactory(){ |
| return fTypeConstraintFactory; |
| } |
| |
| public IConstraintVariableFactory getConstraintVariableFactory(){ |
| return fConstraintVariableFactory; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.wst.jsdt.core.dom.ASTVisitor#visit(org.eclipse.wst.jsdt.core.dom.ArrayInitializer) |
| */ |
| public ITypeConstraint[] create(ArrayInitializer arrayInitializer){ |
| ITypeBinding arrayBinding= arrayInitializer.resolveTypeBinding(); |
| Assert.isTrue(arrayBinding.isArray()); |
| List<Expression> expressions= (List<Expression>)arrayInitializer.expressions(); |
| List<ITypeConstraint> constraints= new ArrayList<ITypeConstraint>(); |
| Type type= getTypeParent(arrayInitializer); |
| ConstraintVariable typeVariable= fConstraintVariableFactory.makeTypeVariable(type); |
| for (Expression each : expressions) { |
| ITypeConstraint[] c= fTypeConstraintFactory.createSubtypeConstraint( |
| fConstraintVariableFactory.makeExpressionOrTypeVariable(each, getContext()), |
| typeVariable); |
| constraints.addAll(Arrays.asList(c)); |
| } |
| return constraints.toArray(new ITypeConstraint[constraints.size()]); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.wst.jsdt.core.dom.ASTVisitor#visit(org.eclipse.wst.jsdt.core.dom.Assignment) |
| */ |
| public ITypeConstraint[] create(Assignment assignment){ |
| return fTypeConstraintFactory.createSubtypeConstraint( |
| fConstraintVariableFactory.makeExpressionOrTypeVariable(assignment.getRightHandSide(), getContext()), |
| fConstraintVariableFactory.makeExpressionOrTypeVariable(assignment.getLeftHandSide(), getContext())); |
| } |
| |
| public ITypeConstraint[] create(CatchClause node) { |
| SingleVariableDeclaration exception= node.getException(); |
| ConstraintVariable nameVariable= fConstraintVariableFactory.makeExpressionOrTypeVariable(exception.getName(), getContext()); |
| |
| ITypeConstraint[] defines= fTypeConstraintFactory.createDefinesConstraint( |
| nameVariable, |
| fConstraintVariableFactory.makeTypeVariable(exception.getType())); |
| |
| ITypeBinding throwable= node.getAST().resolveWellKnownType("java.lang.Throwable"); //$NON-NLS-1$ |
| ITypeConstraint[] catchBound= fTypeConstraintFactory.createSubtypeConstraint( |
| nameVariable, |
| fConstraintVariableFactory.makeRawBindingVariable(throwable)); |
| |
| ArrayList<ITypeConstraint> result= new ArrayList<ITypeConstraint>(); |
| result.addAll(Arrays.asList(defines)); |
| result.addAll(Arrays.asList(catchBound)); |
| return result.toArray(new ITypeConstraint[result.size()]); |
| } |
| |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.wst.jsdt.core.dom.ASTVisitor#visit(org.eclipse.wst.jsdt.core.dom.ClassInstanceCreation) |
| */ |
| public ITypeConstraint[] create(ClassInstanceCreation instanceCreation){ |
| List<ITypeConstraint> arguments= (List<ITypeConstraint>)instanceCreation.arguments(); |
| List<ITypeConstraint> result= new ArrayList<ITypeConstraint>(arguments.size()); |
| IFunctionBinding methodBinding= instanceCreation.resolveConstructorBinding(); |
| result.addAll(Arrays.asList(getArgumentConstraints(arguments, methodBinding))); |
| if (instanceCreation.getAnonymousClassDeclaration() == null){ |
| ConstraintVariable constructorVar= fConstraintVariableFactory.makeExpressionOrTypeVariable(instanceCreation, getContext()); |
| ConstraintVariable typeVar= fConstraintVariableFactory.makeRawBindingVariable(instanceCreation.resolveTypeBinding()); |
| result.addAll(Arrays.asList(fTypeConstraintFactory.createDefinesConstraint(constructorVar, typeVar))); |
| } |
| return result.toArray(new ITypeConstraint[result.size()]); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.wst.jsdt.core.dom.ASTVisitor#visit(org.eclipse.wst.jsdt.core.dom.ConstructorInvocation) |
| */ |
| public ITypeConstraint[] create(ConstructorInvocation invocation){ |
| List<ITypeConstraint> arguments= (List<ITypeConstraint>)invocation.arguments(); |
| List<ITypeConstraint> result= new ArrayList<ITypeConstraint>(arguments.size()); |
| IFunctionBinding methodBinding= invocation.resolveConstructorBinding(); |
| result.addAll(Arrays.asList(getArgumentConstraints(arguments, methodBinding))); |
| return result.toArray(new ITypeConstraint[result.size()]); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.wst.jsdt.core.dom.ASTVisitor#visit(org.eclipse.wst.jsdt.core.dom.FieldAccess) |
| */ |
| public ITypeConstraint[] create(FieldAccess access){ |
| Expression expression= access.getExpression(); |
| SimpleName name= access.getName(); |
| IBinding binding= name.resolveBinding(); |
| if (! (binding instanceof IVariableBinding)) |
| return new ITypeConstraint[0]; |
| IVariableBinding vb= (IVariableBinding)binding; |
| return createConstraintsForAccessToField(vb, expression, access); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.wst.jsdt.core.dom.ASTVisitor#visit(org.eclipse.wst.jsdt.core.dom.FieldDeclaration) |
| */ |
| public ITypeConstraint[] create(FieldDeclaration fd){ |
| List<ITypeConstraint> result= new ArrayList<ITypeConstraint>(); |
| result.addAll(Arrays.asList(getConstraintsFromFragmentList(fd.fragments(), fd.getType()))); |
| result.addAll(getConstraintsForHiding(fd)); |
| result.addAll(getConstraintsForFieldDeclaringTypes(fd)); |
| return result.toArray(new ITypeConstraint[result.size()]); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.wst.jsdt.core.dom.ASTVisitor#visit(org.eclipse.wst.jsdt.core.dom.InstanceofExpression) |
| */ |
| public ITypeConstraint[] create(InstanceofExpression instanceofExpression){ |
| Expression expression= instanceofExpression.getLeftOperand(); |
| Type type= instanceofExpression.getRightOperand(); |
| if (isClassBinding(expression.resolveTypeBinding()) && isClassBinding(type.resolveBinding())) { |
| ConstraintVariable expressionVar= fConstraintVariableFactory.makeExpressionOrTypeVariable(expression, getContext()); |
| ConstraintVariable typeVariable= fConstraintVariableFactory.makeTypeVariable(type); |
| return createOrOrSubtypeConstraint(expressionVar, typeVariable); |
| } else |
| return new ITypeConstraint[0]; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.wst.jsdt.core.dom.ASTVisitor#visit(org.eclipse.wst.jsdt.core.dom.ConditionalExpression) |
| */ |
| public ITypeConstraint[] create(ConditionalExpression node) { |
| List<ITypeConstraint> result= new ArrayList<ITypeConstraint>(); |
| Expression thenExpression= node.getThenExpression(); |
| Expression elseExpression= node.getElseExpression(); |
| ConstraintVariable whole= fConstraintVariableFactory.makeExpressionOrTypeVariable(node, getContext()); |
| ConstraintVariable ev1= fConstraintVariableFactory.makeExpressionOrTypeVariable(thenExpression, getContext()); |
| ConstraintVariable ev2= fConstraintVariableFactory.makeExpressionOrTypeVariable(elseExpression, getContext()); |
| ITypeConstraint[] constraints1= fTypeConstraintFactory.createEqualsConstraint(ev1, ev2); |
| ITypeConstraint[] constraints2= fTypeConstraintFactory.createSubtypeConstraint(ev1, whole); |
| ITypeConstraint[] constraints3= fTypeConstraintFactory.createSubtypeConstraint(ev2, whole); |
| result.addAll(Arrays.asList(constraints1)); |
| result.addAll(Arrays.asList(constraints2)); |
| result.addAll(Arrays.asList(constraints3)); |
| return result.toArray(new ITypeConstraint[result.size()]); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.wst.jsdt.core.dom.ASTVisitor#visit(org.eclipse.wst.jsdt.core.dom.FunctionDeclaration) |
| */ |
| public ITypeConstraint[] create(FunctionDeclaration declaration){ |
| List<ITypeConstraint> result= new ArrayList<ITypeConstraint>(); |
| IFunctionBinding methodBinding= declaration.resolveBinding(); |
| if (methodBinding == null) |
| return new ITypeConstraint[0]; |
| ITypeConstraint[] constraints = fTypeConstraintFactory.createDefinesConstraint( |
| fConstraintVariableFactory.makeDeclaringTypeVariable(methodBinding), |
| fConstraintVariableFactory.makeRawBindingVariable(methodBinding.getDeclaringClass())); |
| result.addAll(Arrays.asList(constraints)); |
| if (! methodBinding.isConstructor() && ! methodBinding.getReturnType().isPrimitive()){ |
| ConstraintVariable returnTypeBindingVariable= fConstraintVariableFactory.makeReturnTypeVariable(methodBinding); |
| ConstraintVariable returnTypeVariable= fConstraintVariableFactory.makeTypeVariable(declaration.getReturnType2()); |
| ITypeConstraint[] defines= fTypeConstraintFactory.createDefinesConstraint( |
| returnTypeBindingVariable, returnTypeVariable); |
| result.addAll(Arrays.asList(defines)); |
| } |
| for (int i= 0, n= declaration.parameters().size(); i < n; i++) { |
| SingleVariableDeclaration paramDecl= (SingleVariableDeclaration)declaration.parameters().get(i); |
| ConstraintVariable parameterTypeVariable= fConstraintVariableFactory.makeParameterTypeVariable(methodBinding, i); |
| ConstraintVariable parameterNameVariable= fConstraintVariableFactory.makeExpressionOrTypeVariable(paramDecl.getName(), getContext()); |
| ITypeConstraint[] constraint= fTypeConstraintFactory.createDefinesConstraint( |
| parameterTypeVariable, parameterNameVariable); |
| result.addAll(Arrays.asList(constraint)); |
| } |
| if (MethodChecks.isVirtual(methodBinding)){ |
| Collection constraintsForOverriding = getConstraintsForOverriding(methodBinding); |
| result.addAll(constraintsForOverriding); |
| } |
| return result.toArray(new ITypeConstraint[result.size()]); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.wst.jsdt.internal.corext.refactoring.typeconstraints.ConstraintCreator#create(org.eclipse.wst.jsdt.core.dom.ParenthesizedExpression) |
| */ |
| public ITypeConstraint[] create(ParenthesizedExpression node) { |
| ConstraintVariable v1= fConstraintVariableFactory.makeExpressionOrTypeVariable(node, getContext()); |
| ConstraintVariable v2= fConstraintVariableFactory.makeExpressionOrTypeVariable(node.getExpression(), getContext()); |
| ITypeConstraint[] equal= fTypeConstraintFactory.createEqualsConstraint(v1, v2); |
| return equal; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.wst.jsdt.core.dom.ASTVisitor#visit(org.eclipse.wst.jsdt.core.dom.FunctionInvocation) |
| */ |
| public ITypeConstraint[] create(FunctionInvocation invocation){ |
| List arguments= invocation.arguments(); |
| List<ITypeConstraint> result= new ArrayList<ITypeConstraint>(arguments.size()); |
| IFunctionBinding methodBinding= invocation.resolveMethodBinding(); |
| if (methodBinding == null) |
| return new ITypeConstraint[0]; |
| ITypeConstraint[] returnTypeConstraint= getReturnTypeConstraint(invocation, methodBinding); |
| result.addAll(Arrays.asList(returnTypeConstraint)); |
| result.addAll(Arrays.asList(getArgumentConstraints(arguments, methodBinding))); |
| if (invocation.getExpression() != null){ |
| if(MethodChecks.isVirtual(methodBinding)){ |
| IFunctionBinding[] rootDefs= getRootDefs(methodBinding); |
| Assert.isTrue(rootDefs.length > 0); |
| ConstraintVariable expressionVar= fConstraintVariableFactory.makeExpressionOrTypeVariable(invocation.getExpression(), getContext()); |
| if (rootDefs.length == 1){ |
| result.addAll(Arrays.asList(fTypeConstraintFactory.createSubtypeConstraint(expressionVar, fConstraintVariableFactory.makeDeclaringTypeVariable(rootDefs[0])))); |
| }else{ |
| Collection<ITypeConstraint> constraints= new ArrayList<ITypeConstraint>(); |
| for (int i= 0; i < rootDefs.length; i++) { |
| ConstraintVariable rootDefTypeVar= fConstraintVariableFactory.makeDeclaringTypeVariable(rootDefs[i]); |
| ITypeConstraint[] tc= fTypeConstraintFactory.createSubtypeConstraint(expressionVar, rootDefTypeVar); |
| constraints.addAll(Arrays.asList(tc)); |
| } |
| ITypeConstraint[] constraintsArray= constraints.toArray(new ITypeConstraint[constraints.size()]); |
| if (constraintsArray.length > 0){ |
| result.add(fTypeConstraintFactory.createCompositeOrTypeConstraint(constraintsArray)); |
| } |
| } |
| } else { |
| ConstraintVariable typeVar= fConstraintVariableFactory.makeDeclaringTypeVariable(methodBinding); |
| ConstraintVariable expressionVar= fConstraintVariableFactory.makeExpressionOrTypeVariable(invocation.getExpression(), getContext()); |
| result.addAll(Arrays.asList(fTypeConstraintFactory.createSubtypeConstraint(expressionVar, typeVar))); |
| } |
| } |
| return result.toArray(new ITypeConstraint[result.size()]); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.wst.jsdt.core.dom.ASTVisitor#visit(org.eclipse.wst.jsdt.core.dom.QualifiedName) |
| */ |
| public ITypeConstraint[] create(QualifiedName qualifiedName){ |
| SimpleName name= qualifiedName.getName(); |
| Name qualifier= qualifiedName.getQualifier(); |
| IBinding nameBinding= name.resolveBinding(); |
| if (nameBinding instanceof IVariableBinding){ |
| IVariableBinding vb= (IVariableBinding)nameBinding; |
| if (vb.isField()) |
| return createConstraintsForAccessToField(vb, qualifier, qualifiedName); |
| } //TODO other bindings |
| return new ITypeConstraint[0]; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.wst.jsdt.core.dom.ASTVisitor#visit(org.eclipse.wst.jsdt.core.dom.ReturnStatement) |
| */ |
| public ITypeConstraint[] create(ReturnStatement returnStatement){ |
| if (returnStatement.getExpression() == null) |
| return new ITypeConstraint[0]; |
| |
| ConstraintVariable returnTypeVariable= fConstraintVariableFactory.makeReturnTypeVariable(returnStatement); |
| return fTypeConstraintFactory.createSubtypeConstraint( |
| fConstraintVariableFactory.makeExpressionOrTypeVariable(returnStatement.getExpression(), getContext()), |
| returnTypeVariable); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.wst.jsdt.core.dom.ASTVisitor#visit(org.eclipse.wst.jsdt.core.dom.SingleVariableDeclaration) |
| */ |
| public ITypeConstraint[] create(SingleVariableDeclaration svd){ |
| ITypeConstraint[] defines= fTypeConstraintFactory.createDefinesConstraint( |
| fConstraintVariableFactory.makeExpressionOrTypeVariable(svd.getName(), getContext()), |
| fConstraintVariableFactory.makeTypeVariable(svd.getType())); |
| if (svd.getInitializer() == null) |
| return defines; |
| ITypeConstraint[] constraints = fTypeConstraintFactory.createSubtypeConstraint( |
| fConstraintVariableFactory.makeExpressionOrTypeVariable(svd.getInitializer(), getContext()), |
| fConstraintVariableFactory.makeExpressionOrTypeVariable(svd.getName(), getContext())); |
| if (defines.length == 0 && constraints.length == 0){ |
| return new ITypeConstraint[0]; |
| } else if (defines.length == 0){ |
| return constraints; |
| } else if (constraints.length == 0){ |
| return defines; |
| } else { |
| List<ITypeConstraint> all= new ArrayList<ITypeConstraint>(); |
| all.addAll(Arrays.asList(defines)); |
| all.addAll(Arrays.asList(constraints)); |
| return all.toArray(new ITypeConstraint[all.size()]); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.wst.jsdt.core.dom.ASTVisitor#visit(org.eclipse.wst.jsdt.core.dom.SuperConstructorInvocation) |
| */ |
| public ITypeConstraint[] create(SuperConstructorInvocation invocation){ |
| List<ITypeConstraint> arguments= invocation.arguments(); |
| List<ITypeConstraint> result= new ArrayList<ITypeConstraint>(arguments.size()); |
| IFunctionBinding methodBinding= invocation.resolveConstructorBinding(); |
| result.addAll(Arrays.asList(getArgumentConstraints(arguments, methodBinding))); |
| return result.toArray(new ITypeConstraint[result.size()]); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.wst.jsdt.core.dom.ASTVisitor#visit(org.eclipse.wst.jsdt.core.dom.SuperFieldAccess) |
| */ |
| public ITypeConstraint[] create(SuperFieldAccess access){ |
| SimpleName name= access.getName(); |
| IBinding binding= name.resolveBinding(); |
| if (! (binding instanceof IVariableBinding)) |
| return new ITypeConstraint[0]; |
| IVariableBinding vb= (IVariableBinding)binding; |
| return createConstraintsForAccessToField(vb, null, access); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.wst.jsdt.core.dom.ASTVisitor#visit(org.eclipse.wst.jsdt.core.dom.SuperMethodInvocation) |
| */ |
| public ITypeConstraint[] create(SuperMethodInvocation invocation){ |
| List<ITypeConstraint> arguments= invocation.arguments(); |
| List<ITypeConstraint> result= new ArrayList<ITypeConstraint>(arguments.size()); |
| IFunctionBinding methodBinding= invocation.resolveMethodBinding(); |
| ITypeConstraint[] returnTypeConstraint= getReturnTypeConstraint(invocation, methodBinding); |
| result.addAll(Arrays.asList(returnTypeConstraint)); |
| result.addAll(Arrays.asList(getArgumentConstraints(arguments, methodBinding))); |
| return result.toArray(new ITypeConstraint[result.size()]); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.wst.jsdt.core.dom.ASTVisitor#visit(org.eclipse.wst.jsdt.core.dom.ThisExpression) |
| */ |
| public ITypeConstraint[] create(ThisExpression expression){ |
| ConstraintVariable thisExpression= fConstraintVariableFactory.makeExpressionOrTypeVariable(expression, getContext()); |
| ConstraintVariable declaringType= fConstraintVariableFactory.makeRawBindingVariable(expression.resolveTypeBinding());//TODO fix this - can't use Decl(M) because 'this' can live outside of methods |
| return fTypeConstraintFactory.createDefinesConstraint(thisExpression, declaringType); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.wst.jsdt.core.dom.ASTVisitor#visit(org.eclipse.wst.jsdt.core.dom.VariableDeclarationExpression) |
| */ |
| public ITypeConstraint[] create(VariableDeclarationExpression vde){ |
| return getConstraintsFromFragmentList(vde.fragments(), vde.getType()); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.wst.jsdt.core.dom.ASTVisitor#visit(org.eclipse.wst.jsdt.core.dom.VariableDeclarationFragment) |
| */ |
| public ITypeConstraint[] create(VariableDeclarationFragment vdf){ |
| if (vdf.getInitializer() == null) |
| return new ITypeConstraint[0]; |
| return fTypeConstraintFactory.createSubtypeConstraint( |
| fConstraintVariableFactory.makeExpressionOrTypeVariable(vdf.getInitializer(), getContext()), |
| fConstraintVariableFactory.makeExpressionOrTypeVariable(vdf.getName(), getContext())); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.wst.jsdt.core.dom.ASTVisitor#visit(org.eclipse.wst.jsdt.core.dom.VariableDeclarationStatement) |
| */ |
| public ITypeConstraint[] create(VariableDeclarationStatement vds){ |
| return getConstraintsFromFragmentList(vds.fragments(), vds.getType()); |
| } |
| |
| |
| //--------- private helpers ----------------// |
| |
| private Collection<ITypeConstraint> getConstraintsForFieldDeclaringTypes(FieldDeclaration fd) { |
| Collection<ITypeConstraint> result= new ArrayList<ITypeConstraint>(fd.fragments().size()); |
| for (Object item : fd.fragments()) { |
| VariableDeclarationFragment varDecl= (VariableDeclarationFragment) item; |
| IVariableBinding binding= varDecl.resolveBinding(); |
| Assert.isTrue(binding.isField()); |
| result.addAll(Arrays.asList(fTypeConstraintFactory.createDefinesConstraint( |
| fConstraintVariableFactory.makeDeclaringTypeVariable(binding), |
| fConstraintVariableFactory.makeRawBindingVariable(binding.getDeclaringClass())))); |
| } |
| return result; |
| } |
| |
| private Collection<ITypeConstraint> getConstraintsForHiding(FieldDeclaration fd) { |
| Collection<ITypeConstraint> result= new ArrayList<ITypeConstraint>(); |
| for (Object item : fd.fragments()) { |
| result.addAll(getConstraintsForHiding((VariableDeclarationFragment) item)); |
| } |
| return result; |
| } |
| |
| private Collection<ITypeConstraint> getConstraintsForHiding(VariableDeclarationFragment fragment) { |
| Collection<ITypeConstraint> result= new ArrayList<ITypeConstraint>(); |
| IVariableBinding fieldBinding= fragment.resolveBinding(); |
| Assert.isTrue(fieldBinding.isField()); |
| Set<ITypeBinding> declaringTypes= getDeclaringSuperTypes(fieldBinding); |
| ConstraintVariable hiddingFieldVar= fConstraintVariableFactory.makeDeclaringTypeVariable(fieldBinding); |
| for (ITypeBinding declaringSuperType : declaringTypes) { |
| IVariableBinding hiddenField= findField(fieldBinding, declaringSuperType); |
| Assert.isTrue(hiddenField.isField()); |
| ConstraintVariable hiddenFieldVar= fConstraintVariableFactory.makeDeclaringTypeVariable(hiddenField); |
| result.addAll(Arrays.asList(fTypeConstraintFactory.createStrictSubtypeConstraint(hiddingFieldVar, hiddenFieldVar))); |
| } |
| return result; |
| } |
| |
| private ITypeConstraint[] getConstraintsFromFragmentList(List<VariableDeclarationFragment> fragments, Type type) { |
| ConstraintVariable typeVariable= fConstraintVariableFactory.makeTypeVariable(type); |
| int size = fragments.size(); |
| List<ITypeConstraint> result= new ArrayList<ITypeConstraint>((size * (size - 1))/2); |
| for (VariableDeclarationFragment fragment1 : fragments) { |
| SimpleName fragment1Name= fragment1.getName(); |
| result.addAll(Arrays.asList(fTypeConstraintFactory.createDefinesConstraint( |
| fConstraintVariableFactory.makeExpressionOrTypeVariable(fragment1Name, getContext()), |
| typeVariable))); |
| for (VariableDeclarationFragment fragment2 : fragments) { |
| result.addAll(Arrays.asList(fTypeConstraintFactory.createEqualsConstraint( |
| fConstraintVariableFactory.makeExpressionOrTypeVariable(fragment1Name, getContext()), |
| fConstraintVariableFactory.makeExpressionOrTypeVariable(fragment2.getName(), getContext())))); |
| } |
| } |
| return result.toArray(new ITypeConstraint[result.size()]); |
| } |
| |
| private Collection<ITypeConstraint> getConstraintsForOverriding(IFunctionBinding overriddingMethod) { |
| Collection<ITypeConstraint> result= new ArrayList<ITypeConstraint>(); |
| Set<ITypeBinding> declaringSupertypes= getDeclaringSuperTypes(overriddingMethod); |
| for (ITypeBinding superType : declaringSupertypes) { |
| IFunctionBinding overriddenMethod= findMethod(overriddingMethod, superType); |
| Assert.isNotNull(overriddenMethod);//because we asked for declaring types |
| if (Bindings.equals(overriddingMethod, overriddenMethod)) continue; |
| ITypeConstraint[] returnTypeConstraint= fTypeConstraintFactory.createEqualsConstraint( |
| fConstraintVariableFactory.makeReturnTypeVariable(overriddenMethod), |
| fConstraintVariableFactory.makeReturnTypeVariable(overriddingMethod)); |
| result.addAll(Arrays.asList(returnTypeConstraint)); |
| Assert.isTrue(overriddenMethod.getParameterTypes().length == overriddingMethod.getParameterTypes().length); |
| for (int i= 0, n= overriddenMethod.getParameterTypes().length; i < n; i++) { |
| ITypeConstraint[] parameterTypeConstraint= fTypeConstraintFactory.createEqualsConstraint( |
| fConstraintVariableFactory.makeParameterTypeVariable(overriddenMethod, i), |
| fConstraintVariableFactory.makeParameterTypeVariable(overriddingMethod, i)); |
| result.addAll(Arrays.asList(parameterTypeConstraint)); |
| } |
| ITypeConstraint[] declaringTypeConstraint= fTypeConstraintFactory.createStrictSubtypeConstraint( |
| fConstraintVariableFactory.makeDeclaringTypeVariable(overriddingMethod), |
| fConstraintVariableFactory.makeDeclaringTypeVariable(overriddenMethod)); |
| result.addAll(Arrays.asList(declaringTypeConstraint)); |
| } |
| return result; |
| } |
| |
| private ITypeConstraint[] getReturnTypeConstraint(Expression invocation, IFunctionBinding methodBinding){ |
| if (methodBinding == null || methodBinding.isConstructor() || methodBinding.getReturnType().isPrimitive()) |
| return new ITypeConstraint[0]; |
| ConstraintVariable returnTypeVariable= fConstraintVariableFactory.makeReturnTypeVariable(methodBinding); |
| ConstraintVariable invocationVariable= fConstraintVariableFactory.makeExpressionOrTypeVariable(invocation, getContext()); |
| return fTypeConstraintFactory.createDefinesConstraint(invocationVariable, returnTypeVariable); |
| } |
| |
| private ITypeConstraint[] getArgumentConstraints(List<?> arguments, IFunctionBinding methodBinding){ |
| List<ITypeConstraint> result= new ArrayList<ITypeConstraint>(arguments.size()); |
| for (int i= 0, n= arguments.size(); i < n; i++) { |
| if (arguments.get(i) instanceof Expression) { |
| Expression argument= (Expression) arguments.get(i); |
| ConstraintVariable expressionVariable= fConstraintVariableFactory.makeExpressionOrTypeVariable(argument, getContext()); |
| ConstraintVariable parameterTypeVariable= fConstraintVariableFactory.makeParameterTypeVariable(methodBinding, i); |
| ITypeConstraint[] argConstraint= fTypeConstraintFactory.createSubtypeConstraint(expressionVariable, parameterTypeVariable); |
| result.addAll(Arrays.asList(argConstraint)); |
| } |
| } |
| return result.toArray(new ITypeConstraint[result.size()]); |
| } |
| |
| private static Type getTypeParent(ArrayInitializer arrayInitializer) { |
| if (arrayInitializer.getParent() instanceof ArrayCreation){ |
| return ((ArrayCreation)arrayInitializer.getParent()).getType().getElementType(); |
| } else if (arrayInitializer.getParent() instanceof ArrayInitializer){ |
| return getTypeParent((ArrayInitializer) arrayInitializer.getParent()); |
| } else if (arrayInitializer.getParent() instanceof VariableDeclaration){ |
| VariableDeclaration parent= (VariableDeclaration)arrayInitializer.getParent(); |
| |
| if (parent.getParent() instanceof VariableDeclarationStatement){ |
| Type type= ((VariableDeclarationStatement)parent.getParent()).getType(); |
| return ASTNodes.getElementType(type); |
| } else if (parent.getParent() instanceof VariableDeclarationExpression){ |
| Type type= ((VariableDeclarationExpression)parent.getParent()).getType(); |
| return ASTNodes.getElementType(type); |
| } else if (parent.getParent() instanceof FieldDeclaration){ |
| Type type= ((FieldDeclaration)parent.getParent()).getType(); |
| return ASTNodes.getElementType(type); |
| } |
| } |
| Assert.isTrue(false);//array initializers are allowed in only 2 places |
| return null; |
| } |
| |
| private ITypeConstraint[] createOrOrSubtypeConstraint(ConstraintVariable var1, ConstraintVariable var2){ |
| ITypeConstraint[] c1= fTypeConstraintFactory.createSubtypeConstraint(var1, var2); |
| ITypeConstraint[] c2= fTypeConstraintFactory.createSubtypeConstraint(var2, var1); |
| if (c1.length == 0 && c2.length == 0){ |
| return new ITypeConstraint[0]; |
| } |
| return new ITypeConstraint[]{ fTypeConstraintFactory.createCompositeOrTypeConstraint(new ITypeConstraint[]{c1[0], c2[0]}) }; |
| } |
| |
| private ITypeConstraint[] createConstraintsForAccessToField(IVariableBinding fieldBinding, Expression qualifier, Expression accessExpression){ |
| Assert.isTrue(fieldBinding.isField()); |
| ITypeConstraint[] defines= fTypeConstraintFactory.createDefinesConstraint( |
| fConstraintVariableFactory.makeExpressionOrTypeVariable(accessExpression, getContext()), |
| fConstraintVariableFactory.makeRawBindingVariable(fieldBinding.getType())); |
| if (qualifier == null) |
| return defines; |
| ITypeConstraint[] subType= fTypeConstraintFactory.createSubtypeConstraint( |
| fConstraintVariableFactory.makeExpressionOrTypeVariable(qualifier, getContext()), |
| fConstraintVariableFactory.makeDeclaringTypeVariable(fieldBinding)); |
| |
| if (defines.length == 0){ |
| return subType; |
| } else if (subType.length == 0){ |
| return defines; |
| } else { |
| return new ITypeConstraint[]{defines[0], subType[0]}; |
| } |
| } |
| |
| private static IVariableBinding findField(IVariableBinding fieldBinding, ITypeBinding type) { |
| if (fieldBinding.getDeclaringClass().equals(type)) |
| return fieldBinding; |
| return Bindings.findFieldInType(type, fieldBinding.getName()); |
| } |
| |
| /* |
| * return Set of ITypeBindings |
| */ |
| private static Set<ITypeBinding> getDeclaringSuperTypes(IVariableBinding fieldBinding) { |
| ITypeBinding[] allSuperTypes= Bindings.getAllSuperTypes(fieldBinding.getDeclaringClass()); |
| Set<ITypeBinding> result= new HashSet<ITypeBinding>(); |
| for (ITypeBinding type : allSuperTypes) { |
| if (findField(fieldBinding, type) != null) |
| result.add(type); |
| } |
| return result; |
| } |
| |
| //--- RootDef ----// |
| protected static IFunctionBinding[] getRootDefs(IFunctionBinding methodBinding) { |
| Set<ITypeBinding> declaringSuperTypes= getDeclaringSuperTypes(methodBinding); |
| Set<IFunctionBinding> result= new LinkedHashSet<IFunctionBinding>(); |
| for (ITypeBinding type : declaringSuperTypes) { |
| if (! containsASuperType(type, declaringSuperTypes)) |
| result.add(findMethod(methodBinding, type)); |
| } |
| |
| if (result.size() == 0){ |
| result.add(methodBinding); |
| } |
| return result.toArray(new IFunctionBinding[result.size()]); |
| } |
| |
| /* |
| * @param declaringSuperTypes Set of ITypeBindings |
| * @return <code>true</code> iff <code>declaringSuperTypes</code> contains a type |
| * which is a strict supertype of <code>type</code> |
| */ |
| private static boolean containsASuperType(ITypeBinding type, Set<ITypeBinding> declaringSuperTypes) { |
| for (ITypeBinding maybeSuperType : declaringSuperTypes) { |
| if (! Bindings.equals(maybeSuperType, type) && Bindings.isSuperType(maybeSuperType, type)) |
| return true; |
| } |
| return false; |
| } |
| |
| /* |
| * return Set of ITypeBindings |
| */ |
| protected static Set<ITypeBinding> getDeclaringSuperTypes(IFunctionBinding methodBinding) { |
| ITypeBinding superClass = methodBinding.getDeclaringClass(); |
| Set<ITypeBinding> allSuperTypes= new LinkedHashSet<ITypeBinding>(); |
| allSuperTypes.addAll(Arrays.asList(Bindings.getAllSuperTypes(superClass))); |
| if (allSuperTypes.isEmpty()) |
| allSuperTypes.add(methodBinding.getDeclaringClass()); //TODO: Why only iff empty? The declaring class is not a supertype ... |
| Set<ITypeBinding> result= new HashSet<ITypeBinding>(); |
| for (ITypeBinding type : allSuperTypes) { |
| if (findMethod(methodBinding, type) != null) |
| result.add(type); |
| } |
| return result; |
| } |
| |
| protected static IFunctionBinding findMethod(IFunctionBinding methodBinding, ITypeBinding type) { |
| if (methodBinding.getDeclaringClass().equals(type)) |
| return methodBinding; |
| return Bindings.findOverriddenMethodInType(type, methodBinding); |
| } |
| |
| private static boolean isClassBinding(ITypeBinding typeBinding){ |
| return typeBinding != null && typeBinding.isClass(); |
| } |
| |
| } |