From bce674ac9a55b14dcd5c5cdebac67332b7bea61f Mon Sep 17 00:00:00 2001 From: John Camelon Date: Wed, 10 Dec 2003 00:07:32 +0000 Subject: [PATCH] Patch for Andrew Niefer. --- core/org.eclipse.cdt.core.tests/ChangeLog | 4 + .../parser/tests/ParserSymbolTableTest.java | 146 +++++++++++++++++- .../parser/ChangeLog-parser | 4 + .../core/parser/pst/ContainerSymbol.java | 52 ++++++- .../core/parser/pst/IContainerSymbol.java | 4 +- .../core/parser/pst/ParserSymbolTable.java | 102 ++++++++++-- .../internal/core/parser/pst/TypeFilter.java | 117 ++++++++++++++ .../internal/core/parser/pst/TypeInfo.java | 27 ++-- 8 files changed, 421 insertions(+), 35 deletions(-) create mode 100644 core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/TypeFilter.java diff --git a/core/org.eclipse.cdt.core.tests/ChangeLog b/core/org.eclipse.cdt.core.tests/ChangeLog index 99a1150cec9..aa2c49a0d84 100644 --- a/core/org.eclipse.cdt.core.tests/ChangeLog +++ b/core/org.eclipse.cdt.core.tests/ChangeLog @@ -1,3 +1,7 @@ +2003-12-09 Andrew Niefer + added ParserSymbolTableTests.testVisibilityDetermination() + added ParserSymbolTableTests.testPrefixFiltering + 2003-12-09 Hoda Amer Modified the Completion Proposal test to include case sensitivity in the order of proposals. diff --git a/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ParserSymbolTableTest.java b/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ParserSymbolTableTest.java index a9c3bb075e6..f870fe91da0 100644 --- a/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ParserSymbolTableTest.java +++ b/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ParserSymbolTableTest.java @@ -11,6 +11,7 @@ package org.eclipse.cdt.core.parser.tests; +import java.util.ArrayList; import java.util.Iterator; import java.util.LinkedList; import java.util.List; @@ -20,6 +21,16 @@ import junit.framework.TestCase; import org.eclipse.cdt.core.parser.ParserLanguage; import org.eclipse.cdt.core.parser.ast.ASTAccessVisibility; +import org.eclipse.cdt.core.parser.ast.ASTClassKind; +import org.eclipse.cdt.core.parser.ast.IASTClassSpecifier; +import org.eclipse.cdt.core.parser.ast.IASTCompilationUnit; +import org.eclipse.cdt.core.parser.ast.IASTField; +import org.eclipse.cdt.core.parser.ast.IASTClassSpecifier.ClassNameType; +import org.eclipse.cdt.core.parser.ast.IASTNode.LookupKind; +import org.eclipse.cdt.internal.core.parser.ast.complete.ASTClassSpecifier; +import org.eclipse.cdt.internal.core.parser.ast.complete.ASTCompilationUnit; +import org.eclipse.cdt.internal.core.parser.ast.complete.ASTField; +import org.eclipse.cdt.internal.core.parser.ast.complete.ASTSymbol; import org.eclipse.cdt.internal.core.parser.pst.IContainerSymbol; import org.eclipse.cdt.internal.core.parser.pst.IDerivableContainerSymbol; import org.eclipse.cdt.internal.core.parser.pst.IParameterizedSymbol; @@ -29,6 +40,7 @@ import org.eclipse.cdt.internal.core.parser.pst.ParserSymbolTable; import org.eclipse.cdt.internal.core.parser.pst.ParserSymbolTableException; import org.eclipse.cdt.internal.core.parser.pst.StandardSymbolExtension; import org.eclipse.cdt.internal.core.parser.pst.TemplateInstance; +import org.eclipse.cdt.internal.core.parser.pst.TypeFilter; import org.eclipse.cdt.internal.core.parser.pst.TypeInfo; import org.eclipse.cdt.internal.core.parser.pst.ParserSymbolTable.Mark; import org.eclipse.cdt.internal.core.parser.pst.TypeInfo.OperatorExpression; @@ -3010,7 +3022,7 @@ public class ParserSymbolTableTest extends TestCase { ISymbol anotherVar = table.newSymbol( "anotherVar", TypeInfo.t_int ); foo.addSymbol( anotherVar ); - List results = foo.prefixLookup( TypeInfo.t_any, "a", false ); + List results = foo.prefixLookup( null, "a", false ); assertTrue( results != null ); assertEquals( results.size(), 2 ); @@ -3044,7 +3056,7 @@ public class ParserSymbolTableTest extends TestCase { D.addSymbol( aField ); D.addSymbol( aMethod ); - List results = D.prefixLookup( TypeInfo.t_any, "a", true ); + List results = D.prefixLookup( null, "a", true ); assertTrue( results != null ); assertEquals( results.size(), 2 ); @@ -3096,7 +3108,7 @@ public class ParserSymbolTableTest extends TestCase { B.addSymbol( af2 ); - List results = B.prefixLookup( TypeInfo.t_any, "a", true ); + List results = B.prefixLookup( null, "a", true ); assertTrue( results != null ); assertEquals( results.size(), 3 ); @@ -3161,7 +3173,7 @@ public class ParserSymbolTableTest extends TestCase { f.addUsingDirective( V ); f.addUsingDirective( W ); - List results = f.prefixLookup( TypeInfo.t_any, "a", false ); + List results = f.prefixLookup( null, "a", false ); assertTrue( results != null ); assertEquals( results.size(), 1 ); @@ -3195,5 +3207,131 @@ public class ParserSymbolTableTest extends TestCase { assertEquals( null, A.qualifiedLookup( "i" ) ); assertEquals( i, g.lookup( "i" ) ); } + + /** + * class A { public: static int i; }; + * class B : private A {}; + * class C : public B, public A {}; + * + * @throws Exception + */ + public void testVisibilityDetermination() throws Exception{ + newTable(); + + IDerivableContainerSymbol A = table.newDerivableContainerSymbol( "A", TypeInfo.t_class ); + ISymbol i = table.newSymbol( "i", TypeInfo.t_int ); + + table.getCompilationUnit().addSymbol( A ); + A.addSymbol( i ); + + IASTCompilationUnit compUnit = new ASTCompilationUnit(table.getCompilationUnit() ); + ISymbolASTExtension cuExtension = new StandardSymbolExtension( table.getCompilationUnit(), (ASTSymbol) compUnit ); + table.getCompilationUnit().setASTExtension( cuExtension ); + + IASTClassSpecifier clsSpec = new ASTClassSpecifier( A, ASTClassKind.CLASS, ClassNameType.IDENTIFIER, ASTAccessVisibility.PUBLIC, 0, 0, 0, new ArrayList( ) ); + ISymbolASTExtension clsExtension = new StandardSymbolExtension( A, (ASTSymbol) clsSpec ); + A.setASTExtension( clsExtension ); + + IASTField field = new ASTField(i, null, null, null, 0, 0, 0, new ArrayList(), false, null, ASTAccessVisibility.PUBLIC ); + ISymbolASTExtension extension = new StandardSymbolExtension( i, (ASTSymbol) field ); + i.setASTExtension( extension ); + + IDerivableContainerSymbol B = table.newDerivableContainerSymbol( "B", TypeInfo.t_class ); + B.addParent( A, false, ASTAccessVisibility.PRIVATE, 0, null ); + table.getCompilationUnit().addSymbol( B ); + + IDerivableContainerSymbol C = table.newDerivableContainerSymbol( "C", TypeInfo.t_class ); + C.addParent( B ); + C.addParent( A ); + table.getCompilationUnit().addSymbol( C ); + + assertTrue( table.getCompilationUnit().isVisible( i, A ) ); + assertFalse( table.getCompilationUnit().isVisible( i, B ) ); + assertTrue( table.getCompilationUnit().isVisible(i, C ) ); + } + + /** + * struct a1{}; + * void aFoo() {} + * int aa; + * class A2{ + * struct a3 {}; + * int a3; + * void aF(); + * void f() { + * int aLocal; + * A(CTRL+SPACE) + * }; + * }; + * @throws Exception + */ + public void testPrefixFiltering() throws Exception{ + newTable(); + IDerivableContainerSymbol a1 = table.newDerivableContainerSymbol( "a1", TypeInfo.t_struct ); + table.getCompilationUnit().addSymbol( a1 ); + + IParameterizedSymbol aFoo = table.newParameterizedSymbol( "aFoo", TypeInfo.t_function ); + table.getCompilationUnit().addSymbol( aFoo ); + + ISymbol aa = table.newSymbol( "aa", TypeInfo.t_int ); + table.getCompilationUnit().addSymbol( aa ); + + IDerivableContainerSymbol A2 = table.newDerivableContainerSymbol( "A2", TypeInfo.t_class ); + table.getCompilationUnit().addSymbol( A2 ); + + IDerivableContainerSymbol a3 = table.newDerivableContainerSymbol( "a3", TypeInfo.t_struct ); + A2.addSymbol( a3 ); + + ISymbol a3_int = table.newSymbol( "a3", TypeInfo.t_int ); + A2.addSymbol( a3_int ); + + IParameterizedSymbol aF = table.newParameterizedSymbol( "aF", TypeInfo.t_function ); + A2.addSymbol( aF ); + + IParameterizedSymbol f = table.newParameterizedSymbol( "f", TypeInfo.t_function ); + A2.addSymbol( f ); + + ISymbol aLocal = table.newSymbol( "aLocal", TypeInfo.t_int ); + f.addSymbol( aLocal ); + + List results = f.prefixLookup( new TypeFilter( LookupKind.STRUCTURES ), "A", false ); + + assertEquals( results.size(), 3 ); + + assertTrue( results.contains( a1 ) ); + assertTrue( results.contains( A2 ) ); + assertTrue( results.contains( a3 ) ); + + results = f.prefixLookup( null, "a", false ); + assertEquals( results.size(), 7 ); + assertTrue( results.contains( aF ) ); + assertTrue( results.contains( A2 ) ); + assertTrue( results.contains( a3_int ) ); + assertTrue( results.contains( a1 ) ); + assertTrue( results.contains( aFoo ) ); + assertTrue( results.contains( aa ) ); + assertTrue( results.contains( aLocal ) ); + + results = f.prefixLookup( new TypeFilter( LookupKind.FUNCTIONS ), "a", false ); + assertEquals( results.size(), 1 ); + assertTrue( results.contains( aFoo ) ); + + results = f.prefixLookup( new TypeFilter( LookupKind.METHODS ), "a", false ); + assertEquals( results.size(), 1 ); + assertTrue( results.contains( aF ) ); + + results = f.prefixLookup( new TypeFilter( LookupKind.LOCAL_VARIABLES ), "a", false ); + assertEquals( results.size(), 1 ); + assertTrue( results.contains( aLocal ) ); + + results = f.prefixLookup( new TypeFilter( LookupKind.VARIABLES ), "a", false ); + assertEquals( results.size(), 1 ); + assertTrue( results.contains( aa ) ); + + results = f.prefixLookup( new TypeFilter( LookupKind.FIELDS), "a", false ); + assertEquals( results.size(), 1 ); + assertTrue( results.contains( a3_int ) ); + }; + } diff --git a/core/org.eclipse.cdt.core/parser/ChangeLog-parser b/core/org.eclipse.cdt.core/parser/ChangeLog-parser index 1e6dbaf7903..92a2ec2ad84 100644 --- a/core/org.eclipse.cdt.core/parser/ChangeLog-parser +++ b/core/org.eclipse.cdt.core/parser/ChangeLog-parser @@ -1,3 +1,7 @@ +2003-12-09 Andrew Niefer + -created TypeFilter to support support filtering of what kind of symbols to find (for prefix lookup 48306) + -added IContainerSymbol.isVisible for bug 48294 + 2003-12-09 Hoda Amer Modified IASTCompletionNode.CompletionKind modified IASTNode.LookupKind diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/ContainerSymbol.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/ContainerSymbol.java index 7651b5a0646..a0745d7168b 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/ContainerSymbol.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/ContainerSymbol.java @@ -22,6 +22,9 @@ import java.util.List; import java.util.ListIterator; import java.util.Map; +import org.eclipse.cdt.core.parser.ast.ASTAccessVisibility; +import org.eclipse.cdt.core.parser.ast.IASTMember; +import org.eclipse.cdt.core.parser.ast.IASTNode; import org.eclipse.cdt.internal.core.parser.pst.ParserSymbolTable.Command; import org.eclipse.cdt.internal.core.parser.pst.ParserSymbolTable.LookupData; @@ -378,8 +381,10 @@ public class ContainerSymbol extends BasicSymbol implements IContainerSymbol { ISymbol foundSymbol = null; LookupData data = new LookupData( name, TypeInfo.t_namespace, getTemplateInstance() ); - data.upperType = TypeInfo.t_union; - + data.filter.addFilteredType( TypeInfo.t_class ); + data.filter.addFilteredType( TypeInfo.t_struct ); + data.filter.addFilteredType( TypeInfo.t_union ); + data.foundItems = ParserSymbolTable.lookupInContained( data, inSymbol ); if( data.foundItems != null ){ @@ -571,8 +576,8 @@ public class ContainerSymbol extends BasicSymbol implements IContainerSymbol { return null; } - public List prefixLookup( TypeInfo.eType type, String prefix, boolean qualified ) throws ParserSymbolTableException{ - LookupData data = new LookupData( prefix, type, getTemplateInstance() ); + public List prefixLookup( TypeFilter filter, String prefix, boolean qualified ) throws ParserSymbolTableException{ + LookupData data = new LookupData( prefix, filter, getTemplateInstance() ); data.qualified = qualified; data.mode = ParserSymbolTable.LookupMode.PREFIX; @@ -607,6 +612,45 @@ public class ContainerSymbol extends BasicSymbol implements IContainerSymbol { } } + public boolean isVisible( ISymbol symbol, IContainerSymbol qualifyingSymbol ){ + ISymbolASTExtension extension = symbol.getASTExtension(); + IASTNode node = extension.getPrimaryDeclaration(); + + if( node instanceof IASTMember ){ + ASTAccessVisibility visibility; + try { + visibility = ParserSymbolTable.getVisibility( symbol, qualifyingSymbol ); + } catch (ParserSymbolTableException e) { + return false; + } + if( visibility == ASTAccessVisibility.PUBLIC ){ + return true; + } + + IContainerSymbol container = getContainingSymbol(); + IContainerSymbol symbolContainer = ( qualifyingSymbol != null ) ? qualifyingSymbol : symbol.getContainingSymbol(); + + if( !symbolContainer.isType( TypeInfo.t_class, TypeInfo.t_union ) || + symbolContainer.equals( container ) ) + { + return true; + } + + //TODO: friendship + if( visibility == ASTAccessVisibility.PROTECTED ) + { + try { + return ( ParserSymbolTable.hasBaseClass( container, symbolContainer ) >= 0 ); + } catch (ParserSymbolTableException e) { + return false; + } + } else { //PRIVATE + return false; + } + } + return true; + } + /* (non-Javadoc) * @see org.eclipse.cdt.internal.core.parser.pst.IContainerSymbol#instantiate(java.util.List) */ diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/IContainerSymbol.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/IContainerSymbol.java index 1fd74524864..3aa91e4c59c 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/IContainerSymbol.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/IContainerSymbol.java @@ -39,7 +39,7 @@ public interface IContainerSymbol extends ISymbol { public Map getContainedSymbols(); - public List prefixLookup( TypeInfo.eType type, String prefix, boolean qualified ) throws ParserSymbolTableException; + public List prefixLookup( TypeFilter filter, String prefix, boolean qualified ) throws ParserSymbolTableException; public ISymbol elaboratedLookup( TypeInfo.eType type, String name ) throws ParserSymbolTableException; public ISymbol lookup( String name ) throws ParserSymbolTableException; @@ -53,4 +53,6 @@ public interface IContainerSymbol extends ISymbol { public IParameterizedSymbol qualifiedFunctionLookup( String name, List parameters ) throws ParserSymbolTableException; public TemplateInstance templateLookup( String name, List arguments ) throws ParserSymbolTableException; public TemplateInstance instantiate( List arguments ) throws ParserSymbolTableException; + + public boolean isVisible( ISymbol symbol, IContainerSymbol qualifyingSymbol ); } diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/ParserSymbolTable.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/ParserSymbolTable.java index 94283fd05bc..fd1f14e9963 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/ParserSymbolTable.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/ParserSymbolTable.java @@ -25,6 +25,9 @@ import java.util.Set; import org.eclipse.cdt.core.parser.Enum; import org.eclipse.cdt.core.parser.ParserLanguage; import org.eclipse.cdt.core.parser.ast.ASTAccessVisibility; +import org.eclipse.cdt.core.parser.ast.IASTMember; +import org.eclipse.cdt.core.parser.ast.IASTNode; +import org.eclipse.cdt.internal.core.parser.pst.IDerivableContainerSymbol.IParentSymbol; import org.eclipse.cdt.internal.core.parser.pst.TypeInfo.PtrOp; /** @@ -90,9 +93,9 @@ public class ParserSymbolTable { */ static protected void lookup( LookupData data, IContainerSymbol inSymbol ) throws ParserSymbolTableException { - if( data.type != TypeInfo.t_any && data.type.compareTo(TypeInfo.t_class) < 0 && data.upperType.compareTo(TypeInfo.t_union) > 0 ){ - throw new ParserSymbolTableException( ParserSymbolTableException.r_BadTypeInfo ); - } +// if( data.type != TypeInfo.t_any && data.type.compareTo(TypeInfo.t_class) < 0 && data.upperType.compareTo(TypeInfo.t_union) > 0 ){ +// throw new ParserSymbolTableException( ParserSymbolTableException.r_BadTypeInfo ); +// } //handle namespace aliases if( inSymbol.isType( TypeInfo.t_namespace ) ){ @@ -352,22 +355,26 @@ public class ParserSymbolTable { private static boolean nameMatches( LookupData data, String name ){ if( data.mode == LookupMode.PREFIX ){ - return name.startsWith( data.name ); + return name.regionMatches( true, 0, data.name, 0, data.name.length() ); } else { return name.equals( data.name ); } } - private static boolean checkType( LookupData data, ISymbol symbol, TypeInfo.eType type, TypeInfo.eType upperType ){ + private static boolean checkType( LookupData data, ISymbol symbol ) { //, TypeInfo.eType type, TypeInfo.eType upperType ){ + if( data.filter == null ){ + return true; + } + if( data.templateInstance != null && symbol.isTemplateMember() ){ if( symbol.isType( TypeInfo.t_type ) ){ symbol = symbol.getTypeSymbol(); } if( symbol.isType( TypeInfo.t_undef ) && symbol.getContainingSymbol().isType( TypeInfo.t_template ) ){ TypeInfo info = (TypeInfo) data.templateInstance.getArgumentMap().get( symbol ); - return info.isType( type, upperType ); + return data.filter.shouldAccept( symbol, info ); } } - return symbol.isType( type, upperType ); + return data.filter.shouldAccept( symbol ); } private static Object collectSymbol(LookupData data, Object object ) throws ParserSymbolTableException { @@ -385,7 +392,7 @@ public class ParserSymbolTable { IContainerSymbol cls = null; while( symbol != null ){ - if( checkType( data, symbol, data.type, data.upperType ) ){ + if( checkType( data, symbol ) ){//, data.type, data.upperType ) ){ if( symbol.isTemplateMember() && data.templateInstance != null ) foundSymbol = new TemplateInstance( symbol.getSymbolTable(), symbol, data.templateInstance.getArgumentMap() ); else @@ -1110,7 +1117,7 @@ public class ParserSymbolTable { * * TBD: Consider rewriting iteratively for performance. */ - static private int hasBaseClass( ISymbol obj, ISymbol base ) throws ParserSymbolTableException { + static protected int hasBaseClass( ISymbol obj, ISymbol base ) throws ParserSymbolTableException { return hasBaseClass( obj, base, false ); } @@ -2242,9 +2249,8 @@ public class ParserSymbolTable { public List parameters; //parameter info for resolving functions public HashSet associated; //associated namespaces for argument dependant lookup public ISymbol stopAt; //stop looking along the stack once we hit this declaration - - public TypeInfo.eType type = TypeInfo.t_any; - public TypeInfo.eType upperType = TypeInfo.t_undef; + public TypeFilter filter = null; + public boolean qualified = false; public boolean ignoreUsingDirectives = false; public boolean usingDirectivesOnly = false; @@ -2257,7 +2263,12 @@ public class ParserSymbolTable { public LookupData( String n, TypeInfo.eType t, ISymbol i ){ name = n; - type = t; + filter = new TypeFilter( t ); + templateInstance = i; + } + public LookupData( String n, TypeFilter f, ISymbol i ){ + name = n; + filter = ( f != null ) ? f : new TypeFilter( TypeInfo.t_any ); templateInstance = i; } } @@ -2372,4 +2383,69 @@ public class ParserSymbolTable { } } + /** + * The visibility of the symbol is modified by the visibility of the base classes + * @param symbol + * @param qualifyingSymbol + * @return + */ + public static ASTAccessVisibility getVisibility(ISymbol symbol, IContainerSymbol qualifyingSymbol) throws ParserSymbolTableException { + + IContainerSymbol container = symbol.getContainingSymbol(); + if( qualifyingSymbol == null || container.equals( qualifyingSymbol ) ){ + ISymbolASTExtension extension = symbol.getASTExtension(); + IASTNode node = extension != null ? extension.getPrimaryDeclaration() : null; + if( node != null && node instanceof IASTMember ){ + return ((IASTMember)node).getVisiblity(); + } else { + throw new ParserSymbolTableException( ParserSymbolTableException.r_InternalError ); + } + } + + if( ! (qualifyingSymbol instanceof IDerivableContainerSymbol) ){ + throw new ParserSymbolTableException( ParserSymbolTableException.r_InternalError ); + } + + List parents = ((IDerivableContainerSymbol) qualifyingSymbol).getParents(); + Iterator iter = parents.iterator(); + IParentSymbol parent = null; + ASTAccessVisibility symbolAccess = null; + ASTAccessVisibility parentAccess = null; + + while( iter.hasNext() ){ + parent = (IParentSymbol) iter.next(); + + if( container == parent.getParent() ){ + parentAccess = parent.getAccess(); + symbolAccess = ((IASTMember)symbol.getASTExtension().getPrimaryDeclaration()).getVisiblity(); + + return ( parentAccess.getEnumValue() > symbolAccess.getEnumValue() ) ? parentAccess : symbolAccess; + } + } + + iter = parents.iterator(); + + //if static or an enumerator, the symbol could be visible through more than one path through the heirarchy, + //so we need to check all paths + boolean checkAllPaths = ( symbol.isType( TypeInfo.t_enumerator ) || symbol.getTypeInfo().checkBit( TypeInfo.isStatic ) ); + ASTAccessVisibility resultingAccess = null; + while( iter.hasNext() ){ + parent = (IParentSymbol) iter.next(); + parentAccess = parent.getAccess(); + symbolAccess = getVisibility( symbol, (IContainerSymbol) parent.getParent() ); + + if( symbolAccess != null ){ + symbolAccess = ( parentAccess.getEnumValue() > symbolAccess.getEnumValue() ) ? parentAccess : symbolAccess; + if( checkAllPaths ){ + if( resultingAccess != null ) + resultingAccess = ( resultingAccess.getEnumValue() > symbolAccess.getEnumValue() ) ? symbolAccess : resultingAccess; + else + resultingAccess = symbolAccess; + } else { + return symbolAccess; + } + } + } + return resultingAccess; + } } diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/TypeFilter.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/TypeFilter.java new file mode 100644 index 00000000000..dda4a92f78a --- /dev/null +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/TypeFilter.java @@ -0,0 +1,117 @@ +/******************************************************************************* + * Copyright (c) 2003 IBM Corporation and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Common Public License v0.5 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/cpl-v05.html + * + * Contributors: + * IBM Corp. - Rational Software - initial implementation + ******************************************************************************/ + +package org.eclipse.cdt.internal.core.parser.pst; + +import java.util.HashSet; +import java.util.Set; + +import org.eclipse.cdt.core.parser.ast.IASTNode.LookupKind; + +/** + * @author aniefer + * + * To change the template for this generated type comment go to + * Window - Preferences - Java - Code Generation - Code and Comments + */ +public class TypeFilter { + + public TypeFilter(){ + acceptedTypes.add( TypeInfo.t_any ); + } + + public TypeFilter( Set types ){ + acceptedTypes.addAll( types ); + } + + public TypeFilter( TypeInfo.eType type ){ + acceptedTypes.add( type ); + } + + public TypeFilter( LookupKind kind ){ + acceptedKinds.add( kind ); + populatedFilteredTypes( kind ); + } + + public void addFilteredType( TypeInfo.eType type ){ + acceptedTypes.add( type ); + } + + public void addFilteredType( LookupKind kind ) { + populatedFilteredTypes( kind ); + acceptedKinds.add( kind ); + } + + public boolean shouldAccept( ISymbol symbol ){ + return shouldAccept( symbol, symbol.getTypeInfo() ); + } + public boolean shouldAccept( ISymbol symbol, TypeInfo typeInfo ){ + if( acceptedTypes.contains( TypeInfo.t_any ) ){ + return true; + } + + if( acceptedKinds.isEmpty() ){ + return acceptedTypes.contains( typeInfo.getType() ); + } + + IContainerSymbol container = symbol.getContainingSymbol(); + + boolean symbolIsMember = container.isType( TypeInfo.t_class, TypeInfo.t_union ); + boolean symbolIsLocal = container.isType( TypeInfo.t_constructor, TypeInfo.t_function ) || + container.isType( TypeInfo.t_block ); + + if( typeInfo.isType( TypeInfo.t_function ) ) + { + if( ( acceptedKinds.contains( LookupKind.FUNCTIONS ) && !symbolIsMember ) || + ( acceptedKinds.contains( LookupKind.METHODS ) && symbolIsMember ) ) + { + return true; + } else { + return false; + } + } + else if ( typeInfo.isType( TypeInfo.t_type ) || typeInfo.isType( TypeInfo.t_bool, TypeInfo.t_enumerator ) ) + { + if( ( acceptedKinds.contains( LookupKind.VARIABLES ) && !symbolIsMember && !symbolIsLocal ) || + ( acceptedKinds.contains( LookupKind.LOCAL_VARIABLES ) && !symbolIsMember && symbolIsLocal ) || + ( acceptedKinds.contains( LookupKind.FIELDS ) && symbolIsMember ) ) + { + return true; + } else { + return false; + } + } + else + { + return acceptedTypes.contains( typeInfo.getType() ); + } + } + + /** + * @param lookupKind + */ + private void populatedFilteredTypes(LookupKind kind) { + if ( kind == LookupKind.STRUCTURES ) { acceptedTypes.add( TypeInfo.t_class ); + acceptedTypes.add( TypeInfo.t_struct ); + acceptedTypes.add( TypeInfo.t_union ); } + else if ( kind == LookupKind.STRUCS ) { acceptedTypes.add( TypeInfo.t_struct ); } + else if ( kind == LookupKind.UNIONS ) { acceptedTypes.add( TypeInfo.t_union ); } + else if ( kind == LookupKind.CLASSES ) { acceptedTypes.add( TypeInfo.t_class ); } + else if ( kind == LookupKind.CONSTRUCTORS ){ acceptedTypes.add( TypeInfo.t_constructor ); } + else if ( kind == LookupKind.NAMESPACES ) { acceptedTypes.add( TypeInfo.t_namespace ); } + else if ( kind == LookupKind.ENUMERATIONS ){ acceptedTypes.add( TypeInfo.t_enumeration ); } + else if ( kind == LookupKind.ENUMERATORS ) { acceptedTypes.add( TypeInfo.t_enumerator ); } + } + + + private Set acceptedTypes = new HashSet(); + private Set acceptedKinds = new HashSet(); +} \ No newline at end of file diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/TypeInfo.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/TypeInfo.java index cf09aa166b1..958832d87c1 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/TypeInfo.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/pst/TypeInfo.java @@ -102,19 +102,20 @@ public class TypeInfo { public static final TypeInfo.eType t_enumeration = new TypeInfo.eType( 6 ); public static final TypeInfo.eType t_constructor = new TypeInfo.eType( 7 ); public static final TypeInfo.eType t_function = new TypeInfo.eType( 8 ); - public static final TypeInfo.eType t_bool = new TypeInfo.eType( 9 ); - public static final TypeInfo.eType t_char = new TypeInfo.eType( 10 ); - public static final TypeInfo.eType t_wchar_t = new TypeInfo.eType( 11 ); - public static final TypeInfo.eType t_int = new TypeInfo.eType( 12 ); - public static final TypeInfo.eType t_float = new TypeInfo.eType( 13 ); - public static final TypeInfo.eType t_double = new TypeInfo.eType( 14 ); - public static final TypeInfo.eType t_void = new TypeInfo.eType( 15 ); - public static final TypeInfo.eType t_enumerator = new TypeInfo.eType( 16 ); - public static final TypeInfo.eType t_block = new TypeInfo.eType( 17 ); - public static final TypeInfo.eType t_template = new TypeInfo.eType( 18 ); - public static final TypeInfo.eType t_asm = new TypeInfo.eType( 19 ); - public static final TypeInfo.eType t_linkage = new TypeInfo.eType( 20 ); - public static final TypeInfo.eType t__Bool = new TypeInfo.eType( 21 ); + public static final TypeInfo.eType t__Bool = new TypeInfo.eType( 9 ); + public static final TypeInfo.eType t_bool = new TypeInfo.eType( 10 ); + public static final TypeInfo.eType t_char = new TypeInfo.eType( 11 ); + public static final TypeInfo.eType t_wchar_t = new TypeInfo.eType( 12 ); + public static final TypeInfo.eType t_int = new TypeInfo.eType( 13 ); + public static final TypeInfo.eType t_float = new TypeInfo.eType( 14 ); + public static final TypeInfo.eType t_double = new TypeInfo.eType( 15 ); + public static final TypeInfo.eType t_void = new TypeInfo.eType( 16 ); + public static final TypeInfo.eType t_enumerator = new TypeInfo.eType( 17 ); + public static final TypeInfo.eType t_block = new TypeInfo.eType( 18 ); + public static final TypeInfo.eType t_template = new TypeInfo.eType( 19 ); + public static final TypeInfo.eType t_asm = new TypeInfo.eType( 20 ); + public static final TypeInfo.eType t_linkage = new TypeInfo.eType( 21 ); + //public static final eType t_templateParameter = new eType( 18 ); public static class eType implements Comparable{