X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;ds=sidebyside;f=case-study%2Fjdt-after%2Fcore%20refactoring%2Forg%2Feclipse%2Fjdt%2Finternal%2Fcorext%2Frefactoring%2Fgenerics%2FInferTypeArgumentsRefactoring.java;fp=case-study%2Fjdt-after%2Fcore%20refactoring%2Forg%2Feclipse%2Fjdt%2Finternal%2Fcorext%2Frefactoring%2Fgenerics%2FInferTypeArgumentsRefactoring.java;h=9f21a1945eb4f577fcf2413ac049b47f1ea44964;hb=1b2798f607d741df30e5197f427381cbff326adc;hp=0000000000000000000000000000000000000000;hpb=246231e4bd9b24345490f369747c0549ca308c4d;p=ifi-stolz-refaktor.git diff --git a/case-study/jdt-after/core refactoring/org/eclipse/jdt/internal/corext/refactoring/generics/InferTypeArgumentsRefactoring.java b/case-study/jdt-after/core refactoring/org/eclipse/jdt/internal/corext/refactoring/generics/InferTypeArgumentsRefactoring.java new file mode 100644 index 00000000..9f21a194 --- /dev/null +++ b/case-study/jdt-after/core refactoring/org/eclipse/jdt/internal/corext/refactoring/generics/InferTypeArgumentsRefactoring.java @@ -0,0 +1,518 @@ +/******************************************************************************* + * 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 null 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> 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> getJavaElementsPerProject(IJavaElement[] elements) { + HashMap> result= new HashMap>(); + for (int i= 0; i < elements.length; i++) { + IJavaElement element= elements[i]; + IJavaProject javaProject= element.getJavaProject(); + ArrayList javaElements= result.get(javaProject); + if (javaElements == null) { + javaElements= new ArrayList(); + result.put(javaProject, javaElements); + } + javaElements.add(element); + } + return result; + } + + private RefactoringStatus check15() throws CoreException { + RefactoringStatus result= new RefactoringStatus(); + HashSet checkedProjects= new HashSet(); + + 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 updates= update.getUpdates(); + + Set> entrySet= updates.entrySet(); + pm.beginTask("", entrySet.size()); //$NON-NLS-1$ + pm.setTaskName(RefactoringCoreMessages.InferTypeArgumentsRefactoring_creatingChanges); + for (Iterator> 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 result= new ArrayList(); + HashMap updates= update.getUpdates(); + Set> entrySet= updates.entrySet(); + for (Iterator> iter= entrySet.iterator(); iter.hasNext();) { + + Entry entry= iter.next(); + + rewrite.setResolveBindings(false); + CuUpdate cuUpdate= entry.getValue(); + + for (Iterator 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 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 true to keep unconstrained type references raw, + * false to infer <?> if possible + * @return the new type arguments, or null iff an argument could not be inferred + */ + private static Type[] getTypeArguments(Type baseType, ArrayList 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 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 getTypeArgumentCvs(ConstraintVariable2 baseCv, InferTypeArgumentsTCModel tCModel) { + Map elementCvs= tCModel.getElementVariables(baseCv); + ArrayList typeArgumentCvs= new ArrayList(); + for (Iterator 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 typeArgumentCvs= getTypeArgumentCvs(methodReceiverCv, tCModel); + for (Iterator 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 arguments= new HashMap(); + 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)); + } +}