--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2000, 2011 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
+ *******************************************************************************/
+package org.eclipse.jdt.internal.corext.refactoring.generics;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.events.SelectionAdapter;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.widgets.Button;
+import org.eclipse.swt.widgets.Composite;
+
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.OperationCanceledException;
+
+import org.eclipse.jface.dialogs.Dialog;
+
+import org.eclipse.ltk.core.refactoring.Change;
+import org.eclipse.ltk.core.refactoring.ChangeDescriptor;
+import org.eclipse.ltk.core.refactoring.Refactoring;
+import org.eclipse.ltk.core.refactoring.RefactoringChangeDescriptor;
+import org.eclipse.ltk.core.refactoring.RefactoringDescriptor;
+import org.eclipse.ltk.core.refactoring.RefactoringStatus;
+
+import org.eclipse.jdt.core.BindingKey;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.IJavaElement;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.dom.ASTNode;
+import org.eclipse.jdt.core.dom.AbstractTypeDeclaration;
+import org.eclipse.jdt.core.dom.CastExpression;
+import org.eclipse.jdt.core.dom.ClassInstanceCreation;
+import org.eclipse.jdt.core.dom.Expression;
+import org.eclipse.jdt.core.dom.Name;
+import org.eclipse.jdt.core.dom.ParameterizedType;
+import org.eclipse.jdt.core.dom.ParenthesizedExpression;
+import org.eclipse.jdt.core.dom.SimpleType;
+import org.eclipse.jdt.core.dom.Type;
+import org.eclipse.jdt.core.dom.TypeLiteral;
+import org.eclipse.jdt.core.refactoring.descriptors.InferTypeArgumentsDescriptor;
+
+import org.eclipse.jdt.internal.core.refactoring.descriptors.RefactoringSignatureDescriptorFactory;
+import org.eclipse.jdt.internal.corext.refactoring.JDTRefactoringDescriptorComment;
+import org.eclipse.jdt.internal.corext.refactoring.JavaRefactoringArguments;
+import org.eclipse.jdt.internal.corext.refactoring.JavaRefactoringDescriptorUtil;
+import org.eclipse.jdt.internal.corext.refactoring.RefactoringCoreMessages;
+import org.eclipse.jdt.internal.corext.refactoring.changes.DynamicValidationStateChange;
+import org.eclipse.jdt.internal.corext.refactoring.generics.InferTypeArgumentsUpdate.CuUpdate;
+import org.eclipse.jdt.internal.corext.refactoring.structure.CompilationUnitRewrite;
+import org.eclipse.jdt.internal.corext.refactoring.typeconstraints.types.TType;
+import org.eclipse.jdt.internal.corext.refactoring.typeconstraints.typesets.EnumeratedTypeSet;
+import org.eclipse.jdt.internal.corext.refactoring.typeconstraints.typesets.TypeSet;
+import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.CastVariable2;
+import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.CollectionElementVariable2;
+import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.ConstraintVariable2;
+import org.eclipse.jdt.internal.corext.refactoring.typeconstraints2.TypeVariable2;
+import org.eclipse.jdt.internal.corext.refactoring.util.TextChangeManager;
+import org.eclipse.jdt.internal.corext.util.JavaModelUtil;
+import org.eclipse.jdt.internal.corext.util.Messages;
+
+import org.eclipse.jdt.ui.JavaElementLabels;
+
+import org.eclipse.jdt.internal.ui.refactoring.InferTypeArgumentsWizard.InferTypeArgumentsInputPage;
+import org.eclipse.jdt.internal.ui.refactoring.RefactoringMessages;
+import org.eclipse.jdt.internal.ui.viewsupport.BasicElementLabels;
+
+public class InferTypeArgumentsRefactoring extends Refactoring {
+
+ public static final String ATTRIBUTE_CLONE= "clone"; //$NON-NLS-1$
+ public static final String ATTRIBUTE_LEAVE= "leave"; //$NON-NLS-1$
+
+ private static final String REWRITTEN= "InferTypeArgumentsRefactoring.rewritten"; //$NON-NLS-1$
+
+ TextChangeManager fChangeManager;
+ public IJavaElement[] fElements;
+ InferTypeArgumentsTCModel fTCModel;
+
+ public boolean fAssumeCloneReturnsSameType;
+ public boolean fLeaveUnconstrainedRaw;
+
+ /**
+ * Creates a new infer type arguments refactoring.
+ * @param elements the elements to process, or <code>null</code> if invoked by scripting
+ */
+ public InferTypeArgumentsRefactoring(IJavaElement[] elements) {
+ fElements= elements;
+ }
+
+ public InferTypeArgumentsRefactoring(JavaRefactoringArguments arguments, RefactoringStatus status) {
+ this(null);
+ RefactoringStatus initializeStatus= initialize(arguments);
+ status.merge(initializeStatus);
+ }
+
+ /*
+ * @see org.eclipse.ltk.core.refactoring.Refactoring#getName()
+ */
+ @Override
+ public String getName() {
+ return RefactoringCoreMessages.InferTypeArgumentsRefactoring_name;
+ }
+
+ public void setAssumeCloneReturnsSameType(boolean assume) {
+ fAssumeCloneReturnsSameType= assume;
+ }
+
+ public boolean getAssumeCloneReturnsSameType() {
+ return fAssumeCloneReturnsSameType;
+ }
+
+ public void setLeaveUnconstrainedRaw(boolean raw) {
+ fLeaveUnconstrainedRaw= raw;
+ }
+
+ public boolean getLeaveUnconstrainedRaw() {
+ return fLeaveUnconstrainedRaw;
+ }
+
+ /*
+ * @see org.eclipse.ltk.core.refactoring.Refactoring#checkInitialConditions(org.eclipse.core.runtime.IProgressMonitor)
+ */
+ @Override
+ public RefactoringStatus checkInitialConditions(IProgressMonitor pm) throws CoreException, OperationCanceledException {
+ RefactoringStatus result= check15();
+ pm.done();
+ return result;
+ }
+
+ /*
+ * @see org.eclipse.ltk.core.refactoring.Refactoring#checkFinalConditions(org.eclipse.core.runtime.IProgressMonitor)
+ */
+ @Override
+ public RefactoringStatus checkFinalConditions(final IProgressMonitor pm) throws CoreException, OperationCanceledException {
+ HashMap<IJavaProject, ArrayList<IJavaElement>> projectsToElements= getJavaElementsPerProject(fElements);
+ pm.beginTask("", projectsToElements.size() + 2); //$NON-NLS-1$
+ final RefactoringStatus result= new RefactoringStatus();
+ try {
+ fTCModel= new InferTypeArgumentsTCModel();
+ return fTCModel.generated_1448362723267319242(this, pm, projectsToElements, result);
+ } finally {
+ pm.done();
+ clearGlobalState();
+ }
+ }
+
+ private void clearGlobalState() {
+ TypeSet.resetCount();
+ EnumeratedTypeSet.resetCount();
+ fTCModel= null;
+ }
+
+ private HashMap<IJavaProject, ArrayList<IJavaElement>> getJavaElementsPerProject(IJavaElement[] elements) {
+ HashMap<IJavaProject, ArrayList<IJavaElement>> result= new HashMap<IJavaProject, ArrayList<IJavaElement>>();
+ for (int i= 0; i < elements.length; i++) {
+ IJavaElement element= elements[i];
+ IJavaProject javaProject= element.getJavaProject();
+ ArrayList<IJavaElement> javaElements= result.get(javaProject);
+ if (javaElements == null) {
+ javaElements= new ArrayList<IJavaElement>();
+ result.put(javaProject, javaElements);
+ }
+ javaElements.add(element);
+ }
+ return result;
+ }
+
+ private RefactoringStatus check15() throws CoreException {
+ RefactoringStatus result= new RefactoringStatus();
+ HashSet<IJavaProject> checkedProjects= new HashSet<IJavaProject>();
+
+ for (int i= 0; i < fElements.length; i++) {
+ IJavaProject javaProject= fElements[i].getJavaProject();
+ if (! checkedProjects.contains(javaProject)) {
+ if (! JavaModelUtil.is50OrHigher(javaProject)) {
+ String message= Messages.format(RefactoringCoreMessages.InferTypeArgumentsRefactoring_not50, BasicElementLabels.getJavaElementName(javaProject.getElementName()));
+ result.addFatalError(message);
+ } else if (! JavaModelUtil.is50OrHigherJRE(javaProject)) {
+ String message= Messages.format(RefactoringCoreMessages.InferTypeArgumentsRefactoring_not50Library, BasicElementLabels.getJavaElementName(javaProject.getElementName()));
+ result.addFatalError(message);
+ }
+ checkedProjects.add(javaProject);
+ }
+ }
+ return result;
+ }
+
+ void rewriteDeclarations(InferTypeArgumentsUpdate update, IProgressMonitor pm) throws CoreException {
+ HashMap<ICompilationUnit, CuUpdate> updates= update.getUpdates();
+
+ Set<Entry<ICompilationUnit, CuUpdate>> entrySet= updates.entrySet();
+ pm.beginTask("", entrySet.size()); //$NON-NLS-1$
+ pm.setTaskName(RefactoringCoreMessages.InferTypeArgumentsRefactoring_creatingChanges);
+ for (Iterator<Entry<ICompilationUnit, CuUpdate>> iter= entrySet.iterator(); iter.hasNext();) {
+ if (pm.isCanceled())
+ throw new OperationCanceledException();
+
+ fTCModel.generated_6166498335838897033(this, pm, iter);
+ }
+
+ }
+
+ public static ParameterizedType[] inferArguments(SimpleType[] types, InferTypeArgumentsUpdate update, InferTypeArgumentsTCModel model, CompilationUnitRewrite rewrite) {
+ for (int i= 0; i < types.length; i++) {
+ types[i].setProperty(REWRITTEN, null);
+ }
+ List<ParameterizedType> result= new ArrayList<ParameterizedType>();
+ HashMap<ICompilationUnit, CuUpdate> updates= update.getUpdates();
+ Set<Entry<ICompilationUnit, CuUpdate>> entrySet= updates.entrySet();
+ for (Iterator<Entry<ICompilationUnit, CuUpdate>> iter= entrySet.iterator(); iter.hasNext();) {
+
+ Entry<ICompilationUnit, CuUpdate> entry= iter.next();
+
+ rewrite.setResolveBindings(false);
+ CuUpdate cuUpdate= entry.getValue();
+
+ for (Iterator<CollectionElementVariable2> cvIter= cuUpdate.getDeclarations().iterator(); cvIter.hasNext();) {
+ ConstraintVariable2 cv= cvIter.next();
+ ParameterizedType newNode= rewriteConstraintVariable(cv, rewrite, model, false, types);
+ if (newNode != null)
+ result.add(newNode);
+ }
+ }
+ return result.toArray(new ParameterizedType[result.size()]);
+ }
+
+ static ParameterizedType rewriteConstraintVariable(ConstraintVariable2 cv, CompilationUnitRewrite rewrite, InferTypeArgumentsTCModel tCModel, boolean leaveUnconstraindRaw, SimpleType[] types) {
+ if (cv instanceof CollectionElementVariable2) {
+ ConstraintVariable2 parentElement= ((CollectionElementVariable2) cv).getParentConstraintVariable();
+ if (parentElement instanceof TypeVariable2) {
+ TypeVariable2 typeCv= (TypeVariable2) parentElement;
+ return rewriteTypeVariable(typeCv, rewrite, tCModel, leaveUnconstraindRaw, types);
+ } else {
+ //only rewrite type variables
+ }
+ }
+ return null;
+ }
+
+ private static ParameterizedType rewriteTypeVariable(TypeVariable2 typeCv, CompilationUnitRewrite rewrite, InferTypeArgumentsTCModel tCModel, boolean leaveUnconstraindRaw, SimpleType[] types) {
+ ASTNode node= typeCv.getRange().getNode(rewrite.getRoot());
+ if (node instanceof Name && node.getParent() instanceof Type) {
+ Type originalType= (Type) node.getParent();
+
+ if (types != null && !has(types, originalType))
+ return null;
+
+ // Must rewrite all type arguments in one batch. Do the rewrite when the first one is encountered; skip the others.
+ Object rewritten= originalType.getProperty(REWRITTEN);
+ if (rewritten == REWRITTEN)
+ return null;
+ originalType.setProperty(REWRITTEN, REWRITTEN);
+
+ ArrayList<CollectionElementVariable2> typeArgumentCvs= getTypeArgumentCvs(typeCv, tCModel);
+ Type[] typeArguments= getTypeArguments(originalType, typeArgumentCvs, rewrite, tCModel, leaveUnconstraindRaw);
+ if (typeArguments == null)
+ return null;
+
+ Type movingType= (Type) rewrite.getASTRewrite().createMoveTarget(originalType);
+ ParameterizedType newType= rewrite.getAST().newParameterizedType(movingType);
+
+ for (int i= 0; i < typeArguments.length; i++) {
+ newType.typeArguments().add(typeArguments[i]);
+ }
+
+ rewrite.getASTRewrite().replace(originalType, newType, rewrite.createGroupDescription(RefactoringCoreMessages.InferTypeArgumentsRefactoring_addTypeArguments));
+ return newType;
+ } else {//TODO: other node types?
+ return null;
+ }
+ }
+
+ private static boolean has(SimpleType[] types, Type originalType) {
+ for (int i= 0; i < types.length; i++) {
+ if (types[i] == originalType)
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * @param baseType the base type
+ * @param typeArgumentCvs type argument constraint variables
+ * @param rewrite the cu rewrite
+ * @param tCModel the type constraints model
+ * @param leaveUnconstraindRaw <code>true</code> to keep unconstrained type references raw,
+ * <code>false</code> to infer <code><?></code> if possible
+ * @return the new type arguments, or <code>null</code> iff an argument could not be inferred
+ */
+ private static Type[] getTypeArguments(Type baseType, ArrayList<CollectionElementVariable2> typeArgumentCvs, CompilationUnitRewrite rewrite, InferTypeArgumentsTCModel tCModel, boolean leaveUnconstraindRaw) {
+ if (typeArgumentCvs.size() == 0)
+ return null;
+
+ Type[] typeArguments= new Type[typeArgumentCvs.size()];
+ for (int i= 0; i < typeArgumentCvs.size(); i++) {
+ CollectionElementVariable2 elementCv= typeArgumentCvs.get(i);
+ Type typeArgument;
+ TType chosenType= InferTypeArgumentsConstraintsSolver.getChosenType(elementCv);
+ if (chosenType != null) {
+ if (chosenType.isWildcardType() && ! unboundedWildcardAllowed(baseType))
+ return null; // can't e.g. write "new ArrayList<?>()".
+ if (chosenType.isParameterizedType()) // workaround for bug 99124
+ chosenType= chosenType.getTypeDeclaration();
+ BindingKey bindingKey= new BindingKey(chosenType.getBindingKey());
+ typeArgument= rewrite.getImportRewrite().addImportFromSignature(bindingKey.toSignature(), rewrite.getAST());
+ ArrayList<CollectionElementVariable2> nestedTypeArgumentCvs= getTypeArgumentCvs(elementCv, tCModel);
+ Type[] nestedTypeArguments= getTypeArguments(typeArgument, nestedTypeArgumentCvs, rewrite, tCModel, leaveUnconstraindRaw); //recursion
+ if (nestedTypeArguments != null) {
+ ParameterizedType parameterizedType= rewrite.getAST().newParameterizedType(typeArgument);
+ for (int j= 0; j < nestedTypeArguments.length; j++)
+ parameterizedType.typeArguments().add(nestedTypeArguments[j]);
+ typeArgument= parameterizedType;
+ }
+
+ } else { // couldn't infer an element type (no constraints)
+ if (leaveUnconstraindRaw) {
+ // every guess could be wrong => leave the whole thing raw
+ return null;
+ } else {
+ if (unboundedWildcardAllowed(baseType)) {
+ typeArgument= rewrite.getAST().newWildcardType();
+ } else {
+ String object= rewrite.getImportRewrite().addImport("java.lang.Object"); //$NON-NLS-1$
+ typeArgument= (Type) rewrite.getASTRewrite().createStringPlaceholder(object, ASTNode.SIMPLE_TYPE);
+ }
+ }
+// ASTNode baseTypeParent= baseType.getParent();
+// if (baseTypeParent instanceof ClassInstanceCreation) {
+// //No ? allowed. Take java.lang.Object.
+// typeArgument= rewrite.getAST().newSimpleType(rewrite.getAST().newName(rewrite.getImportRewrite().addImport("java.lang.Object"))); //$NON-NLS-1$
+// } else if (baseTypeParent instanceof ArrayCreation || baseTypeParent instanceof InstanceofExpression) {
+// //Only ? allowed.
+// typeArgument= rewrite.getAST().newWildcardType();
+// } else {
+// //E.g. field type: can put anything. Choosing ? in order to be most constraining.
+// typeArgument= rewrite.getAST().newWildcardType();
+// }
+ }
+ typeArguments[i]= typeArgument;
+ }
+ return typeArguments;
+ }
+
+ private static ArrayList<CollectionElementVariable2> getTypeArgumentCvs(ConstraintVariable2 baseCv, InferTypeArgumentsTCModel tCModel) {
+ Map<String, CollectionElementVariable2> elementCvs= tCModel.getElementVariables(baseCv);
+ ArrayList<CollectionElementVariable2> typeArgumentCvs= new ArrayList<CollectionElementVariable2>();
+ for (Iterator<CollectionElementVariable2> iter= elementCvs.values().iterator(); iter.hasNext();) {
+ CollectionElementVariable2 elementCv= iter.next();
+ int index= elementCv.getDeclarationTypeVariableIndex();
+ if (index != CollectionElementVariable2.NOT_DECLARED_TYPE_VARIABLE_INDEX) {
+ while (index >= typeArgumentCvs.size())
+ typeArgumentCvs.add(null); // fill with null until set(index, ..) is possible
+ typeArgumentCvs.set(index, elementCv);
+ }
+ }
+ return typeArgumentCvs;
+ }
+
+ private static boolean unboundedWildcardAllowed(Type originalType) {
+ ASTNode parent= originalType.getParent();
+ while (parent instanceof Type)
+ parent= parent.getParent();
+
+ if (parent instanceof ClassInstanceCreation) {
+ return false;
+ } else if (parent instanceof AbstractTypeDeclaration) {
+ return false;
+ } else if (parent instanceof TypeLiteral) {
+ return false;
+ }
+ return true;
+ }
+
+ static ASTNode rewriteCastVariable(CastVariable2 castCv, CompilationUnitRewrite rewrite, InferTypeArgumentsTCModel tCModel) {//, List positionGroups) {
+ ASTNode node= castCv.getRange().getNode(rewrite.getRoot());
+
+ ConstraintVariable2 expressionVariable= castCv.getExpressionVariable();
+ ConstraintVariable2 methodReceiverCv= tCModel.getMethodReceiverCv(expressionVariable);
+ if (methodReceiverCv != null) {
+ TType chosenReceiverType= InferTypeArgumentsConstraintsSolver.getChosenType(methodReceiverCv);
+ if (chosenReceiverType == null)
+ return null;
+ else if (! InferTypeArgumentsTCModel.isAGenericType(chosenReceiverType))
+ return null;
+ else if (hasUnboundElement(methodReceiverCv, tCModel))
+ return null;
+ }
+
+ CastExpression castExpression= (CastExpression) node;
+ Expression expression= castExpression.getExpression();
+ ASTNode nodeToReplace;
+ if (castExpression.getParent() instanceof ParenthesizedExpression)
+ nodeToReplace= castExpression.getParent();
+ else
+ nodeToReplace= castExpression;
+
+ Expression newExpression= (Expression) rewrite.getASTRewrite().createMoveTarget(expression);
+ rewrite.getASTRewrite().replace(nodeToReplace, newExpression, rewrite.createGroupDescription(RefactoringCoreMessages.InferTypeArgumentsRefactoring_removeCast));
+ rewrite.getImportRemover().registerRemovedNode(nodeToReplace);
+ return newExpression;
+ }
+
+ private static boolean hasUnboundElement(ConstraintVariable2 methodReceiverCv, InferTypeArgumentsTCModel tCModel) {
+ ArrayList<CollectionElementVariable2> typeArgumentCvs= getTypeArgumentCvs(methodReceiverCv, tCModel);
+ for (Iterator<CollectionElementVariable2> iter= typeArgumentCvs.iterator(); iter.hasNext();) {
+ CollectionElementVariable2 elementCv= iter.next();
+ TType chosenElementType= InferTypeArgumentsConstraintsSolver.getChosenType(elementCv);
+ if (chosenElementType == null)
+ return true;
+ }
+ return false;
+ }
+
+ /*
+ * @see org.eclipse.ltk.core.refactoring.Refactoring#createChange(org.eclipse.core.runtime.IProgressMonitor)
+ */
+ @Override
+ public Change createChange(IProgressMonitor pm) throws CoreException, OperationCanceledException {
+ pm.beginTask("", 1); //$NON-NLS-1$
+ try {
+ DynamicValidationStateChange result= new DynamicValidationStateChange(RefactoringCoreMessages.InferTypeArgumentsRefactoring_name, fChangeManager.getAllChanges()) {
+
+ @Override
+ public final ChangeDescriptor getDescriptor() {
+ final Map<String, String> arguments= new HashMap<String, String>();
+ final IJavaProject project= getSingleProject();
+ final String description= RefactoringCoreMessages.InferTypeArgumentsRefactoring_descriptor_description;
+ final String header= project != null ? Messages.format(RefactoringCoreMessages.InferTypeArgumentsRefactoring_descriptor_description_project, BasicElementLabels.getJavaElementName(project.getElementName())) : RefactoringCoreMessages.InferTypeArgumentsRefactoring_descriptor_description;
+ final String name= project != null ? project.getElementName() : null;
+ final JDTRefactoringDescriptorComment comment= new JDTRefactoringDescriptorComment(name, this, header);
+ final String[] settings= new String[fElements.length];
+ for (int index= 0; index < settings.length; index++)
+ settings[index]= JavaElementLabels.getTextLabel(fElements[index], JavaElementLabels.ALL_FULLY_QUALIFIED);
+ comment.addSetting(JDTRefactoringDescriptorComment.createCompositeSetting(RefactoringCoreMessages.InferTypeArgumentsRefactoring_original_elements, settings));
+ if (fAssumeCloneReturnsSameType)
+ comment.addSetting(RefactoringCoreMessages.InferTypeArgumentsRefactoring_assume_clone);
+ if (fLeaveUnconstrainedRaw)
+ comment.addSetting(RefactoringCoreMessages.InferTypeArgumentsRefactoring_leave_unconstrained);
+ final InferTypeArgumentsDescriptor descriptor= RefactoringSignatureDescriptorFactory.createInferTypeArgumentsDescriptor(name, description, comment.asString(), arguments, RefactoringDescriptor.STRUCTURAL_CHANGE | RefactoringDescriptor.MULTI_CHANGE);
+ for (int index= 0; index < fElements.length; index++)
+ arguments.put(JavaRefactoringDescriptorUtil.ATTRIBUTE_ELEMENT + (index + 1), JavaRefactoringDescriptorUtil.elementToHandle(name, fElements[index]));
+ arguments.put(ATTRIBUTE_CLONE, Boolean.valueOf(fAssumeCloneReturnsSameType).toString());
+ arguments.put(ATTRIBUTE_LEAVE, Boolean.valueOf(fLeaveUnconstrainedRaw).toString());
+ return new RefactoringChangeDescriptor(descriptor);
+ }
+ };
+ return result;
+ } finally {
+ pm.done();
+ }
+ }
+
+ private IJavaProject getSingleProject() {
+ IJavaProject first= null;
+ for (int index= 0; index < fElements.length; index++) {
+ final IJavaProject project= fElements[index].getJavaProject();
+ if (project != null) {
+ if (first == null)
+ first= project;
+ else if (!project.equals(first))
+ return null;
+ }
+ }
+ return first;
+ }
+
+ private RefactoringStatus initialize(JavaRefactoringArguments arguments) {
+ return arguments.generated_8680542984146802295(this);
+ }
+
+ public void generated_578007568261867975(final InferTypeArgumentsInputPage infertypeargumentsinputpage, Composite result, Button cloneCheckBox) {
+ cloneCheckBox.setText(RefactoringMessages.InferTypeArgumentsWizard_assumeCloneSameType);
+ boolean assumeCloneValue= infertypeargumentsinputpage.fSettings.getBoolean(InferTypeArgumentsInputPage.ASSUME_CLONE_RETURNS_SAME_TYPE);
+ setAssumeCloneReturnsSameType(assumeCloneValue);
+ cloneCheckBox.setSelection(assumeCloneValue);
+ cloneCheckBox.addSelectionListener(new SelectionAdapter() {
+ @Override
+ public void widgetSelected(SelectionEvent e) {
+ infertypeargumentsinputpage.setAssumeCloseReturnsSameType(((Button)e.widget).getSelection());
+ }
+ });
+
+ Button leaveRawCheckBox= new Button(result, SWT.CHECK);
+ leaveRawCheckBox.setText(RefactoringMessages.InferTypeArgumentsWizard_leaveUnconstrainedRaw);
+ boolean leaveRawValue= infertypeargumentsinputpage.fSettings.getBoolean(InferTypeArgumentsInputPage.LEAVE_UNCONSTRAINED_RAW);
+ setLeaveUnconstrainedRaw(leaveRawValue);
+ leaveRawCheckBox.setSelection(leaveRawValue);
+ leaveRawCheckBox.addSelectionListener(new SelectionAdapter() {
+ @Override
+ public void widgetSelected(SelectionEvent e) {
+ infertypeargumentsinputpage.setLeaveUnconstrainedRaw(((Button)e.widget).getSelection());
+ }
+ });
+
+ infertypeargumentsinputpage.updateStatus();
+ Dialog.applyDialogFont(result);
+ }
+
+ public void generated_2960112356189999578(InferTypeArgumentsInputPage infertypeargumentsinputpage) {
+ setAssumeCloneReturnsSameType(infertypeargumentsinputpage.fSettings.getBoolean(InferTypeArgumentsInputPage.ASSUME_CLONE_RETURNS_SAME_TYPE));
+ setLeaveUnconstrainedRaw(infertypeargumentsinputpage.fSettings.getBoolean(InferTypeArgumentsInputPage.LEAVE_UNCONSTRAINED_RAW));
+ }
+}
git://git.uio.no / ifi-stolz-refaktor.git / blobdiff