Attachment #168827 for bug #305694

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

Lines 83-88 Link Here

(-)src/org/eclipse/wst/jsdt/internal/codeassist/CompletionEngine.java (-58 / +99 lines)
83	import org.eclipse.wst.jsdt.internal.compiler.ast.ConstructorDeclaration;	83	import org.eclipse.wst.jsdt.internal.compiler.ast.ConstructorDeclaration;
84	import org.eclipse.wst.jsdt.internal.compiler.ast.Expression;	84	import org.eclipse.wst.jsdt.internal.compiler.ast.Expression;
85	import org.eclipse.wst.jsdt.internal.compiler.ast.FieldDeclaration;	85	import org.eclipse.wst.jsdt.internal.compiler.ast.FieldDeclaration;
		86	import org.eclipse.wst.jsdt.internal.compiler.ast.FieldReference;
86	import org.eclipse.wst.jsdt.internal.compiler.ast.ImportReference;	87	import org.eclipse.wst.jsdt.internal.compiler.ast.ImportReference;
87	import org.eclipse.wst.jsdt.internal.compiler.ast.Initializer;	88	import org.eclipse.wst.jsdt.internal.compiler.ast.Initializer;
88	import org.eclipse.wst.jsdt.internal.compiler.ast.InstanceOfExpression;	89	import org.eclipse.wst.jsdt.internal.compiler.ast.InstanceOfExpression;
Lines 623-629 Link Here
623	flatEnclosingTypeNames = CharOperation.concatWith(acceptedType.enclosingTypeNames, '.');	624	flatEnclosingTypeNames = CharOperation.concatWith(acceptedType.enclosingTypeNames, '.');
624	typeName = CharOperation.concat(flatEnclosingTypeNames, simpleTypeName, '.');	625	typeName = CharOperation.concat(flatEnclosingTypeNames, simpleTypeName, '.');
625	}	626	}
626	char[] fullyQualifiedName = CharOperation.concat(packageName, typeName, '.');	627
		628	char[] fullyQualifiedName = typeName;
		629	if(CharOperation.indexOf('.', typeName) < 0) {
		630	fullyQualifiedName = CharOperation.concat(packageName, typeName, '.');
		631	}
627		632
628	if (this.knownTypes.containsKey(fullyQualifiedName)) continue next;	633	if (this.knownTypes.containsKey(fullyQualifiedName)) continue next;
629		634
Lines 1150-1156 Link Here
1150	relevance += computeRelevanceForQualification(isQualified);	1155	relevance += computeRelevanceForQualification(isQualified);
1151	relevance += computeRelevanceForClass();	1156	relevance += computeRelevanceForClass();
1152	relevance += computeRelevanceForException(simpleTypeName);	1157	relevance += computeRelevanceForException(simpleTypeName);
1153		1158
		1159	// put proposals that have '_' at the start of their final segment down the list
		1160	char[] lastSegment = CharOperation.lastSegment(completionName, '.');
		1161	if(CharOperation.indexOf('_', lastSegment) == 0) {
		1162	relevance--;
		1163	}
1154	this.noProposal = false;	1164	this.noProposal = false;
1155	if(!this.requestor.isIgnored(CompletionProposal.TYPE_REF)) {	1165	if(!this.requestor.isIgnored(CompletionProposal.TYPE_REF)) {
1156	createTypeProposal(packageName, typeName, modifiers, accessibility, completionName, relevance);	1166	createTypeProposal(packageName, typeName, modifiers, accessibility, completionName, relevance);
Lines 1641-1707 Link Here
1641	long completionPosition = access.nameSourcePosition;	1651	long completionPosition = access.nameSourcePosition;
1642	setSourceRange((int) (completionPosition >>> 32), (int) completionPosition);	1652	setSourceRange((int) (completionPosition >>> 32), (int) completionPosition);
1643		1653
1644	this.completionToken = access.token;
1645		1654
1646	if (qualifiedBinding.problemId() == ProblemReasons.NotFound) {	1655
1647	// complete method members with missing return type	1656	// this.assistNodeIsClass = true;
1648	// class X {	1657	// this.assistNodeIsConstructor = true;
1649	// Missing f() {return null;}	1658
1650	// void foo() {	1659	// can be the start of a qualified type name
1651	// f().\|	1660	if (qualifiedBinding == null) {
1652	// }	1661
1653	// }	1662	this.completionToken = computeToken(access);
1654	if (this.assistNodeInJavadoc == 0 &&	1663	setSourceRange((int) (completionPosition >>> 32) - (this.completionToken.length - access.token.length), (int) completionPosition);
1655	(this.requestor.isAllowingRequiredProposals(CompletionProposal.FIELD_REF, CompletionProposal.TYPE_REF) \|\|	1664
1656	this.requestor.isAllowingRequiredProposals(CompletionProposal.METHOD_REF, CompletionProposal.TYPE_REF))) {	1665	ObjectVector typesFound = new ObjectVector();
1657	ProblemMethodBinding problemMethodBinding = (ProblemMethodBinding) qualifiedBinding;	1666	findTypesAndPackages(this.completionToken, scope, typesFound);
1658	findFieldsAndMethodsFromMissingReturnType(
1659	problemMethodBinding.selector,
1660	problemMethodBinding.parameters,
1661	scope,
1662	access,
1663	insideTypeAnnotation);
1664	}
1665	} else {	1667	} else {
1666	if (!access.isInsideAnnotation) {	1668	this.completionToken = access.token;
1667	if (!this.requestor.isIgnored(CompletionProposal.KEYWORD)) {	1669	if (qualifiedBinding.problemId() == ProblemReasons.NotFound) {
1668	findKeywords(this.completionToken, new char[][]{Keywords.NEW}, false, false);	1670	// complete method members with missing return type
		1671	// class X {
		1672	// Missing f() {return null;}
		1673	// void foo() {
		1674	// f().\|
		1675	// }
		1676	// }
		1677	if (this.assistNodeInJavadoc == 0 &&
		1678	(this.requestor.isAllowingRequiredProposals(CompletionProposal.FIELD_REF, CompletionProposal.TYPE_REF) \|\|
		1679	this.requestor.isAllowingRequiredProposals(CompletionProposal.METHOD_REF, CompletionProposal.TYPE_REF))) {
		1680	ProblemMethodBinding problemMethodBinding = (ProblemMethodBinding) qualifiedBinding;
		1681	findFieldsAndMethodsFromMissingReturnType(
		1682	problemMethodBinding.selector,
		1683	problemMethodBinding.parameters,
		1684	scope,
		1685	access,
		1686	insideTypeAnnotation);
1669	}	1687	}
1670		1688	} else {
1671	findFieldsAndMethods(	1689	if (!access.isInsideAnnotation) {
1672	this.completionToken,	1690	if (!this.requestor.isIgnored(CompletionProposal.KEYWORD)) {
1673	((TypeBinding) qualifiedBinding),	1691	findKeywords(this.completionToken, new char[][]{Keywords.NEW}, false, false);
1674	scope,	1692	}
1675	access,	1693
1676	scope,	1694	findFieldsAndMethods(
1677	access.isStatic,	1695	this.completionToken,
1678	false,	1696	((TypeBinding) qualifiedBinding),
1679	access.receiver instanceof SuperReference,	1697	scope,
1680	null,	1698	access,
1681	null,	1699	scope,
1682	null,	1700	access.isStatic,
1683	false);	1701	false,
1684	if (qualifiedBinding instanceof FunctionTypeBinding) {	1702	access.receiver instanceof SuperReference,
1685	FunctionTypeBinding functionTypeBinding = (FunctionTypeBinding) qualifiedBinding;	1703	null,
1686	if (functionTypeBinding.functionBinding!=null && functionTypeBinding.functionBinding.isConstructor())	1704	null,
1687	{	1705	null,
1688	ReferenceBinding declaringClass = (ReferenceBinding)functionTypeBinding.functionBinding.returnType;	1706	false);
1689	findFieldsAndMethods(	1707	if (qualifiedBinding instanceof FunctionTypeBinding) {
1690	this.completionToken,	1708	FunctionTypeBinding functionTypeBinding = (FunctionTypeBinding) qualifiedBinding;
1691	declaringClass,	1709	if (functionTypeBinding.functionBinding!=null && functionTypeBinding.functionBinding.isConstructor())
1692	scope,	1710	{
1693	access,	1711	ReferenceBinding declaringClass = (ReferenceBinding)functionTypeBinding.functionBinding.returnType;
1694	scope,	1712	findFieldsAndMethods(
1695	true,	1713	this.completionToken,
1696	false,	1714	declaringClass,
1697	access.receiver instanceof SuperReference,	1715	scope,
1698	null,	1716	access,
1699	null,	1717	scope,
1700	null,	1718	true,
1701	false);	1719	false,
		1720	access.receiver instanceof SuperReference,
		1721	null,
		1722	null,
		1723	null,
		1724	false);
		1725
		1726	}
1702		1727
1703	}	1728	}
1704
1705	}	1729	}
1706	}	1730	}
1707	}	1731	}
Lines 7720-7724 Link Here
7720		7744
7721	return result;	7745	return result;
7722	}	7746	}
		7747
		7748	private char[] computeToken(FieldReference field) {
		7749	char[] currentToken = field.token;
		7750	boolean addDot = false;
		7751	if(currentToken != null && currentToken.length == 0)
		7752	addDot = true;
		7753	if(field.receiver != null) {
		7754	if(field.receiver instanceof SingleNameReference) {
		7755	currentToken = CharOperation.concat(((SingleNameReference)field.receiver).token, currentToken, '.');
		7756	} else if(field.receiver instanceof FieldReference) {
		7757	currentToken = CharOperation.concat(computeToken((FieldReference) field.receiver), currentToken, '.');
		7758	}
		7759	}
		7760	if(addDot)
		7761	currentToken = CharOperation.append(currentToken, '.');
		7762	return currentToken;
		7763	}
7723		7764
7724	}	7765	}

Lines 32-37 Link Here

(-)src/org/eclipse/wst/jsdt/internal/codeassist/complete/CompletionOnMemberAccess.java (+5 lines)
32	* which should be replaced by the completion.	32	* which should be replaced by the completion.
33	*/	33	*/
34		34
		35	import org.eclipse.wst.jsdt.internal.compiler.ast.ASTNode;
35	import org.eclipse.wst.jsdt.internal.compiler.ast.Expression;	36	import org.eclipse.wst.jsdt.internal.compiler.ast.Expression;
36	import org.eclipse.wst.jsdt.internal.compiler.ast.FieldReference;	37	import org.eclipse.wst.jsdt.internal.compiler.ast.FieldReference;
37	import org.eclipse.wst.jsdt.internal.compiler.ast.MessageSend;	38	import org.eclipse.wst.jsdt.internal.compiler.ast.MessageSend;
Lines 100-103 Link Here
100	throw new CompletionNodeFound(this, this.receiverType, scope);	101	throw new CompletionNodeFound(this, this.receiverType, scope);
101	// array types are passed along to find the length field	102	// array types are passed along to find the length field
102	}	103	}
		104
		105	public TypeBinding resolveForAllocation(BlockScope scope, ASTNode location) {
		106	throw new CompletionNodeFound(this, scope);
		107	}
103	}	108	}

Lines 434-440 Link Here

(-)src/org/eclipse/wst/jsdt/internal/core/SearchableEnvironment.java (-1 / +1 lines)
434	}	434	}
435	int lastDotIndex = CharOperation.lastIndexOf('.', prefix);	435	int lastDotIndex = CharOperation.lastIndexOf('.', prefix);
436	char[] qualification, simpleName;	436	char[] qualification, simpleName;
437	if (lastDotIndex < 0) {	437	if (lastDotIndex < 0 \|\| true) {
438	qualification = null;	438	qualification = null;
439	if (camelCaseMatch) {	439	if (camelCaseMatch) {
440	simpleName = prefix;	440	simpleName = prefix;

Lines 1-5 Link Here

(-)src/org/eclipse/wst/jsdt/internal/core/index/DiskIndex.java (-2 / +2 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2007 IBM Corporation and others.	2	* Copyright (c) 2000, 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 52-58 Link Here
52	private int bufferIndex, bufferEnd; // used when reading from the file into the streamBuffer	52	private int bufferIndex, bufferEnd; // used when reading from the file into the streamBuffer
53	private int streamEnd; // used when writing data from the streamBuffer to the file	53	private int streamEnd; // used when writing data from the streamBuffer to the file
54		54
55	public static final String SIGNATURE= "INDEX VERSION 1.121"; //$NON-NLS-1$	55	public static final String SIGNATURE= "INDEX VERSION 1.122"; //$NON-NLS-1$
56	private static final char[] SIGNATURE_CHARS = SIGNATURE.toCharArray();	56	private static final char[] SIGNATURE_CHARS = SIGNATURE.toCharArray();
57	public static boolean DEBUG = false;	57	public static boolean DEBUG = false;
58		58

Lines 1-5 Link Here

(-)src/org/eclipse/wst/jsdt/internal/core/search/indexing/AbstractIndexer.java (-1 / +4 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2009 IBM Corporation and others.	2	* Copyright (c) 2000, 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 100-105 Link Here
100	packageName == null ? CharOperation.NO_CHAR : packageName);	100	packageName == null ? CharOperation.NO_CHAR : packageName);
101		101
102	addIndexEntry(TYPE_DECL, indexKey);	102	addIndexEntry(TYPE_DECL, indexKey);
		103
		104	indexKey = TypeDeclarationPattern.createIndexKey(modifiers, CharOperation.concat(packageName, name, '.'), packageName, enclosingTypeNames, secondary);
		105	addIndexEntry(TYPE_DECL, indexKey);
103	}	106	}
104	public void addTypeReference(char[] typeName) {	107	public void addTypeReference(char[] typeName) {
105	if (typeName!=null)	108	if (typeName!=null)

Lines 142-152 Link Here

(-)src/org/eclipse/wst/jsdt/internal/core/search/matching/TypeDeclarationPattern.java (-5 / +5 lines)
142	this(matchRule);	142	this(matchRule);
143		143
144	int index;	144	int index;
145	if (simpleName!=null && (index=CharOperation.lastIndexOf('.',simpleName)) >0)	145	// if (simpleName!=null && (index=CharOperation.lastIndexOf('.',simpleName)) >0)
146	{	146	// {
147	pkg=CharOperation.subarray(simpleName, 0, index);	147	// pkg=CharOperation.subarray(simpleName, 0, index);
148	simpleName=CharOperation.subarray(simpleName, index+1, simpleName.length);	148	// simpleName=CharOperation.subarray(simpleName, index+1, simpleName.length);
149	}	149	// }
150		150
151	this.pkg = isCaseSensitive() ? pkg : CharOperation.toLowerCase(pkg);	151	this.pkg = isCaseSensitive() ? pkg : CharOperation.toLowerCase(pkg);
152	if (isCaseSensitive() \|\| enclosingTypeNames == null) {	152	if (isCaseSensitive() \|\| enclosingTypeNames == null) {




  */
public class LazyJavaTypeCompletionProposal extends LazyJavaCompletionProposal {
	/** Triggers for types. Do not modify. */
	protected static final char[] TYPE_TRIGGERS= new char[] { '\t', '[', '(', ' ' };
	/** Triggers for types in javadoc. Do not modify. */
	protected static final char[] JDOC_TYPE_TRIGGERS= new char[] { '#', '}', ' ', '.' };


		 if (fProposal.getKind() == CompletionProposal.TYPE_REF &&  fInvocationContext.getCoreContext().isInJsdocText())
			 return getSimpleTypeName();
		
		String qualifiedTypeName= replacement;
// 		if (qualifiedTypeName.indexOf('.') == -1)
// 			// default package - no imports needed 
// 			return qualifiedTypeName;

 		/*
		 * If the user types in the qualification, don't force import rewriting on him - insert the

	 */
	protected String computeSortString() {
		// try fast sort string to avoid display string creation
		return getQualifiedTypeName();
	}
	
	/*

Return to bug 305694

Lines 39-45 Link Here

(-)src/org/eclipse/wst/jsdt/internal/ui/text/java/LazyJavaTypeCompletionProposal.java (-6 / +6 lines)
39	*/	39	*/
40	public class LazyJavaTypeCompletionProposal extends LazyJavaCompletionProposal {	40	public class LazyJavaTypeCompletionProposal extends LazyJavaCompletionProposal {
41	/** Triggers for types. Do not modify. */	41	/** Triggers for types. Do not modify. */
42	protected static final char[] TYPE_TRIGGERS= new char[] { '.', '\t', '[', '(', ' ' };	42	protected static final char[] TYPE_TRIGGERS= new char[] { '\t', '[', '(', ' ' };
43	/** Triggers for types in javadoc. Do not modify. */	43	/** Triggers for types in javadoc. Do not modify. */
44	protected static final char[] JDOC_TYPE_TRIGGERS= new char[] { '#', '}', ' ', '.' };	44	protected static final char[] JDOC_TYPE_TRIGGERS= new char[] { '#', '}', ' ', '.' };
45		45
Lines 84-93 Link Here
84	if (fProposal.getKind() == CompletionProposal.TYPE_REF && fInvocationContext.getCoreContext().isInJsdocText())	84	if (fProposal.getKind() == CompletionProposal.TYPE_REF && fInvocationContext.getCoreContext().isInJsdocText())
85	return getSimpleTypeName();	85	return getSimpleTypeName();
86		86
87	String qualifiedTypeName= getQualifiedTypeName();	87	String qualifiedTypeName= replacement;
88	if (qualifiedTypeName.indexOf('.') == -1)	88	// if (qualifiedTypeName.indexOf('.') == -1)
89	// default package - no imports needed	89	// // default package - no imports needed
90	return qualifiedTypeName;	90	// return qualifiedTypeName;
91		91
92	/*	92	/*
93	* If the user types in the qualification, don't force import rewriting on him - insert the	93	* If the user types in the qualification, don't force import rewriting on him - insert the
Lines 339-345 Link Here
339	*/	339	*/
340	protected String computeSortString() {	340	protected String computeSortString() {
341	// try fast sort string to avoid display string creation	341	// try fast sort string to avoid display string creation
342	return getSimpleTypeName() + Character.MIN_VALUE + getQualifiedTypeName();	342	return getQualifiedTypeName();
343	}	343	}
344		344
345	/*	345	/*