Changeset 866

Show
Ignore:
Timestamp:
10/21/07 21:11:50 (1 year ago)
Author:
phoenix
Message:

Mmrnmhrm 0.2.1 RC:
* Name resolving: added support for sequential lookup scopes (statement blocks and enum bodies).
* Code completion: duplicates or occluded names are no longer presented.
* Integrated Descent's DDOC parser to UI hovers.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/dtool/.classpath

    r773 r866  
    22<classpath> 
    33    <classpathentry kind="src" path="src"/> 
    4     <classpathentry kind="src" path="src-descent.core/src"/> 
    5     <classpathentry kind="src" path="src-descent.core/src-util"/> 
    64    <classpathentry kind="src" path="libs/ini4j-0.2.6/src/classes"/> 
    75    <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/> 

  • trunk/dtool/META-INF/MANIFEST.MF

    r804 r866  
    55Bundle-Version: 0.2.0.qualifier 
    66Bundle-ClassPath: DTool.jar 
    7 Export-Package: descent.core.compiler, 
    8  descent.core.dom, 
    9  descent.internal.compiler.parser, 
    10  descent.internal.compiler.parser.ast, 
    11  melnorme.miscutil, 
    12  melnorme.miscutil.log, 
    13  melnorme.miscutil.tree, 
    14  dtool, 
     7Export-Package: dtool, 
    158 dtool.ast, 
    169 dtool.ast.declarations, 
    …… 
    2619Bundle-Vendor: %pluginProvider 
    2720Bundle-RequiredExecutionEnvironment: J2SE-1.5 
    28 Require-Bundle: org.eclipse.dltk.core, 
     21Require-Bundle: dtool.descent.core;visibility:=reexport, 
     22 org.eclipse.dltk.core, 
    2923 org.eclipse.core.runtime 

  • trunk/dtool/src-descent.core/src/descent/internal/compiler/parser/StandardLibraryHelper.java

    r758 r866  
    99import descent.core.compiler.CharOperation; 
    1010import descent.core.dom.AST; 
     11import descent.core.dom.CompilationUnitResolver; 
    1112 
    1213 
    …… 
    102103                } 
    103104            } 
    104             //CompilationUnitResolver.resolve(module); 
     105            CompilationUnitResolver.resolve(module); 
    105106        } catch (Exception e) { 
    106107            e.printStackTrace(); 

  • trunk/dtool/src/dtool/ast/declarations/DeclarationStaticIfIsType.java

    r804 r866  
    5858    } 
    5959     
     60    /** This is a special scope, where the IsTypeDefUnit is available. */ 
    6061    public class IsTypeScope extends ASTNeoNode implements IScopeNode { 
    6162 
    …… 
    8384        } 
    8485         
    85         //@Override 
    86         public IScope getAdaptedScope() { 
    87             return this; 
     86        public boolean hasSequentialLookup() { 
     87            return false; 
    8888        } 
     89         
    8990    } 
    9091     

  • trunk/dtool/src/dtool/ast/declarations/NodeList.java

    r804 r866  
    2626 
    2727    public static NodeList createNodeList(Statement body) { 
     28        if(body == null) 
     29            return null; 
    2830        if(body instanceof CompoundStatement) { 
    2931            CompoundStatement cst = (CompoundStatement) body; 

  • trunk/dtool/src/dtool/ast/declarations/PartialPackageDefUnit.java

    r758 r866  
    7575    } 
    7676     
     77    public boolean hasSequentialLookup() { 
     78        return false; 
     79    } 
     80     
    7781} 

  • trunk/dtool/src/dtool/ast/declarations/PartialPackageDefUnitOfModule.java

    r758 r866  
    3535    public String toStringAsElement() { 
    3636        if(module != null) 
    37             return getName() + "." + module.toStringAsElement(); 
     37            return getName() /*+ "." + module.toStringAsElement()*/; 
    3838        else { 
    39             return getName() + "." + moduleRef.module; 
     39            return getName() /*+ "." + moduleRef.module*/; 
    4040        } 
    4141    } 

  • trunk/dtool/src/dtool/ast/declarations/PartialPackageDefUnitOfPackage.java

    r758 r866  
    2222    @Override 
    2323    public String toStringAsElement() { 
    24         return getName() + "." + child.toStringAsElement(); 
     24        return getName() /*+ "." + child.toStringAsElement()*/; 
    2525    } 
    2626 

  • trunk/dtool/src/dtool/ast/definitions/DefUnit.java

    r773 r866  
    66import descent.internal.compiler.parser.IdentifierExp; 
    77import dtool.ast.ASTNeoNode; 
    8 import dtool.refmodel.IScope; 
    9 import dtool.refmodel.IScopeAdaptable; 
    108import dtool.refmodel.IScopeNode; 
    119 
    …… 
    1311 * Abstract class for all AST elements that define a new named entity. 
    1412 */ 
    15 public abstract class DefUnit extends ASTNeoNode implements    IScopeAdaptable { 
     13public abstract class DefUnit extends ASTNeoNode { 
    1614     
    1715 
    …… 
    9290     * May be null if the scope is not found. */ 
    9391    public abstract IScopeNode getMembersScope(); 
    94  
    95     //@Override 
    96     public IScope getAdaptedScope() { 
    97         return getMembersScope(); 
    98     } 
    9992     
    10093    @Override 

  • trunk/dtool/src/dtool/ast/definitions/DefinitionAggregate.java

    r758 r866  
    4949    } 
    5050     
     51    public boolean hasSequentialLookup() { 
     52        return false; 
     53    } 
     54     
    5155    @Override 
    5256    public String toStringForHoverSignature() { 

  • trunk/dtool/src/dtool/ast/definitions/DefinitionEnum.java

    r758 r866  
    6767        return null; 
    6868    } 
     69     
     70    public boolean hasSequentialLookup() { 
     71        return true; 
     72    } 
    6973 
    7074    @SuppressWarnings("unchecked") 

  • trunk/dtool/src/dtool/ast/definitions/DefinitionFunction.java

    r758 r866  
    107107    } 
    108108     
     109    public boolean hasSequentialLookup() { 
     110        return false; 
     111    } 
     112     
    109113 
    110114    public Iterator<IFunctionParameter> getMembersIterator() { 

  • trunk/dtool/src/dtool/ast/definitions/DefinitionTemplate.java

    r758 r866  
    5555    } 
    5656 
    57      
    58      
    5957    public List<IScope> getSuperScopes() { 
    6058        // TODO: template super scope 
    …… 
    6260    } 
    6361     
     62    //@Override 
     63    public boolean hasSequentialLookup() { 
     64        return false; 
     65    } 
     66 
    6467 
    6568    public Iterator<? extends IASTNode> getMembersIterator() { 

  • trunk/dtool/src/dtool/ast/definitions/EnumMember.java

    r758 r866  
    1414    public EnumMember(descent.internal.compiler.parser.EnumMember elem) { 
    1515        super(elem); 
    16         convertNode(elem.ident); 
     16        convertNode(elem); 
    1717        this.value = Expression.convert(elem.value); 
    1818    } 

  • trunk/dtool/src/dtool/ast/definitions/FunctionParameter.java

    r758 r866  
    1515import dtool.refmodel.NodeUtil; 
    1616 
     17import static melnorme.miscutil.Assert.assertFail; 
    1718import static melnorme.miscutil.Assert.assertNotNull; 
    1819 
    …… 
    2829         
    2930         
    30         if(elem.type instanceof TypeBasic && ((TypeBasic)elem.type).ty.name == null) 
     31        if(elem.type instanceof TypeBasic && ((TypeBasic)elem.type).ty.name == null) { 
     32            assertFail(); 
    3133            this.type = null; 
    32         else  
     34        } else  
    3335            this.type = ReferenceConverter.convertType(elem.type); 
    3436        assertNotNull(this.type); 

  • trunk/dtool/src/dtool/ast/definitions/Module.java

    r804 r866  
    151151    } 
    152152     
     153    //@Override 
    153154    public List<IScope> getSuperScopes() { 
    154155        return null; 
    155156    } 
     157     
     158    //@Override 
     159    public boolean hasSequentialLookup() { 
     160        return false; 
     161    } 
    156162 
     163 
     164    //@Override 
    157165    public Iterator<? extends ASTNeoNode> getMembersIterator() { 
    158166        return Arrays.asList(members).iterator(); 

  • trunk/dtool/src/dtool/ast/definitions/NamelessParameter.java

    r758 r866  
    1212import static melnorme.miscutil.Assert.assertNotNull; 
    1313 
     14 
     15/**  
     16 * A nameless function parameter, such as in: <br> 
     17 * <code> void func(int, int); </code> 
     18 */ 
    1419public class NamelessParameter extends ASTNeoNode implements IFunctionParameter { 
    1520 

  • trunk/dtool/src/dtool/ast/definitions/NativeDefUnit.java

    r773 r866  
    1616public abstract class NativeDefUnit extends DefUnit implements INativeDefUnit, IScopeNode { 
    1717 
     18    /** A module like class, contained all native defunits. */ 
    1819    public static class NativesScope implements IScope { 
    1920 
    …… 
    2930            return this; 
    3031        } 
    31          
    32         //@Override 
    33         public IScope getAdaptedScope() { 
    34             return this; 
    35         } 
    3632 
    3733        //@Override 
    3834        public List<IScope> getSuperScopes() { 
    3935            return null; 
     36        } 
     37         
     38        //@Override 
     39        public boolean hasSequentialLookup() { 
     40            return false; 
    4041        } 
    4142         
    …… 
    8485    public abstract IScopeNode getMembersScope(); 
    8586     
     87    public boolean hasSequentialLookup() { 
     88        return false; 
     89    } 
     90     
    8691    //public abstract IScope getSuperScope(); 
    8792 

  • trunk/dtool/src/dtool/ast/expressions/ExpCall.java

    r758 r866  
    4646        } 
    4747         
    48         DefUnitSearch search = new DefUnitSearch("opCall", this); 
     48        DefUnitSearch search = new DefUnitSearch("opCall", null); 
    4949        ReferenceResolver.findDefUnitInScope(defUnit.getMembersScope(), search); 
    5050        for (Iterator<DefUnit> iter = search.getDefUnits().iterator(); iter.hasNext();) { 

  • trunk/dtool/src/dtool/ast/references/CommonRefQualified.java

    r758 r866  
    5252    public static void doQualifiedSearch(CommonDefUnitSearch search, CommonRefQualified qref) { 
    5353        Collection<DefUnit> defunits = qref.findRootDefUnits(); 
    54         findDefUnitInDefUnitScopes(defunits, search); 
     54        findDefUnitInMultipleDefUnitScopes(defunits, search); 
    5555    } 
    5656     
    57     public static void findDefUnitInDefUnitScopes( 
     57    public static void findDefUnitInMultipleDefUnitScopes( 
    5858            Collection<DefUnit> defunits, CommonDefUnitSearch search) { 
    5959        if(defunits == null) 

  • trunk/dtool/src/dtool/ast/references/CommonRefSingle.java

    r758 r866  
    1212import dtool.refmodel.DefUnitSearch; 
    1313import dtool.refmodel.IScopeNode; 
    14 import dtool.refmodel.NodeUtil; 
    1514import dtool.refmodel.PrefixDefUnitSearch; 
    1615import dtool.refmodel.ReferenceResolver; 
    …… 
    4645    @Override 
    4746    public Collection<DefUnit> findTargetDefUnits(boolean findOneOnly) { 
    48         DefUnitSearch search = new DefUnitSearch(name, this, findOneOnly); 
     47        DefUnitSearch search = new DefUnitSearch(name, this, this.getOffset(), 
     48                findOneOnly); 
    4949        CommonRefSingle.doSearchForPossiblyQualifiedSingleRef(search, this); 
    5050        return search.getDefUnits(); 
    …… 
    7373            } 
    7474        } 
    75         IScopeNode lookupScope = NodeUtil.getOuterScope(refSingle); 
     75 
     76        IScopeNode lookupScope = ReferenceResolver.getStartingScope(refSingle); 
    7677        ReferenceResolver.findDefUnitInExtendedScope(lookupScope, search); 
    7778    } 

  • trunk/dtool/src/dtool/ast/references/NamedReference.java

    r804 r866  
    1515     
    1616    /** Return wheter this reference can match the given defunit. 
    17      * This is a very lightweight method that only compared the defunit's  
     17     * This is a very lightweight method that only compares the defunit's  
    1818     * name with the identifier of this reference, if any. 
    1919     * XXX: Qualified refs, how should they compare?  

  • trunk/dtool/src/dtool/ast/references/RefImportSelection.java

    r758 r866  
    4444    @Override 
    4545    public Collection<DefUnit> findTargetDefUnits(boolean findOneOnly) { 
    46         DefUnitSearch search = new DefUnitSearch(name, (Reference) this, findOneOnly); 
     46        DefUnitSearch search = new DefUnitSearch(name, this, findOneOnly); 
    4747        RefModule refMod = impSel.moduleRef; 
    48         CommonRefQualified.findDefUnitInDefUnitScopes(refMod.findTargetDefUnits(findOneOnly), search); 
     48        CommonRefQualified.findDefUnitInMultipleDefUnitScopes(refMod.findTargetDefUnits(findOneOnly), search); 
    4949        return search.getDefUnits(); 
    5050    } 
    …… 
    5353    public void doSearch(PrefixDefUnitSearch search) { 
    5454        RefModule refMod = impSel.moduleRef; 
    55         CommonRefQualified.findDefUnitInDefUnitScopes(refMod.findTargetDefUnits(false), search); 
     55        CommonRefQualified.findDefUnitInMultipleDefUnitScopes( 
     56                refMod.findTargetDefUnits(false), search); 
    5657    } 
    5758     

  • trunk/dtool/src/dtool/ast/references/RefTemplateInstance.java

    r804 r866  
    2929        Assert.isTrue(tplIdent.ident != null); 
    3030        this.name = new String(tplIdent.ident); 
    31         if (this.tiargs == null) 
     31        if (tiargs == null) 
    3232            this.tiargs = ASTNeoNode.NO_ELEMENTS; 
    3333        else 

  • trunk/dtool/src/dtool/ast/statements/BlockStatement.java

    r773 r866  
    6464    } 
    6565     
     66    public boolean hasSequentialLookup() { 
     67        return true; 
     68    } 
     69     
    6670    //@Override 
    67     public IScope getAdaptedScope() { 
     71    /*public IScope getAdaptedScope() { 
    6872        return this; 
    69     } 
     73    }*/ 
    7074 
    7175} 

  • trunk/dtool/src/dtool/ast/statements/StatementForeach.java

    r758 r866  
    1818    public StatementForeach(ForeachStatement elem) { 
    1919        convertNode(elem); 
    20         // TODO: foreach parameters, unitest too. 
     20        // TODO: implement foreach parameters, and unittest them. 
    2121        //this.params = new IFunctionParameter[elem.arguments.size()];  
    2222        //DescentASTConverter.convertMany(elem.arguments.toArray(), this.params); 

  • trunk/dtool/src/dtool/ast/statements/StatementForeachRange.java

    r758 r866  
    88import dtool.ast.expressions.Expression; 
    99import dtool.ast.expressions.Resolvable; 
    10 import dtool.descentadapter.DescentASTConverter; 
    1110 
    1211public class StatementForeachRange extends Statement { 
    …… 
    2019    public StatementForeachRange(ForeachRangeStatement elem) { 
    2120        convertNode(elem); 
    22         this.param = (IFunctionParameter) DescentASTConverter.convertElem(elem.arg); 
     21        // TODO: implement foreach parameters, and unittest them. 
     22        //this.param = (IFunctionParameter) DescentASTConverter.convertElem(elem.arg); 
     23        this.param = null; 
    2324        this.lwr = Expression.convert(elem.lwr); 
    2425        this.upr = Expression.convert(elem.upr); 

  • trunk/dtool/src/dtool/ast/statements/StatementTry.java

    r773 r866  
    5858        } 
    5959         
    60         //@Override 
    61         public IScope getAdaptedScope() { 
    62             return this; 
     60        public boolean hasSequentialLookup() { 
     61            return false; 
    6362        } 
     63 
    6464    } 
    6565 

  • trunk/dtool/src/dtool/refmodel/CommonDefUnitSearch.java

    r758 r866  
    2727 
    2828    /** Flag for stop searching when suitable matches are found. */ 
    29     protected boolean findOnlyOne; 
     29    protected final boolean findOnlyOne; 
    3030    /** The scope where the reference is located.  
    3131     * Used for protection access restrictions. */ 
    32     protected IScopeNode refScope; 
    33  
     32    protected final IScopeNode refScope; 
     33    /** The offset of the reference.  
     34     * Used to check availability in statement scopes. */ 
     35    protected final int refOffset; 
    3436    /** Cached value of the reference's module scope. */ 
    3537    protected IScope refModuleScope;  
    …… 
    3840 
    3941 
     42    public CommonDefUnitSearch(IScopeNode refScope, int refOffset) { 
     43        this(refScope, refOffset, false); 
     44    } 
    4045     
    41     public CommonDefUnitSearch(IScopeNode refScope) { 
     46    public CommonDefUnitSearch(IScopeNode refScope, int refOffset, boolean findOneOnly) {  
    4247        this.searchedScopes = new ArrayList<IScope>(4); 
    4348        this.refScope = refScope; 
     49        this.refOffset = refOffset; 
     50        this.findOnlyOne = findOneOnly; 
    4451    } 
    4552     
     53 
    4654    /** Return whether we have already search the given scope or not. */ 
    4755    public boolean hasSearched(IScope scope) { 

  • trunk/dtool/src/dtool/refmodel/DefUnitSearch.java

    r758 r866  
    66import dtool.ast.declarations.PartialPackageDefUnit; 
    77import dtool.ast.definitions.DefUnit; 
    8 import dtool.ast.expressions.Resolvable; 
     8import dtool.ast.references.Reference; 
    99 
    1010/** 
    …… 
    1919    protected boolean matchesArePartialDefUnits = false; 
    2020 
    21     public DefUnitSearch(String name, Resolvable searchref) { 
    22         this(name, searchref, false); 
     21    @Deprecated 
     22    public DefUnitSearch(String searchName, Reference searchref) { 
     23        this(searchName, searchref, -1, false); 
    2324    } 
    2425     
    25     public DefUnitSearch(String searchName, Resolvable searchref, boolean findOneOnly) { 
    26         super(NodeUtil.getOuterScope(searchref)); 
     26    @Deprecated 
     27    public DefUnitSearch(String searchName, Reference searchref, int refOffset) { 
     28        this(searchName, searchref, refOffset, false); 
     29    } 
     30     
     31    @Deprecated 
     32    public DefUnitSearch(String searchName, Reference searchref, 
     33             boolean findOneOnly) { 
     34        this(searchName, searchref, -1, findOneOnly); 
     35    } 
     36     
     37    @Deprecated 
     38    public DefUnitSearch(String searchName, Reference searchref, 
     39            int refOffset, boolean findOneOnly) { 
     40        super(NodeUtil.getOuterScope(searchref), refOffset, findOneOnly); 
    2741        this.searchName = searchName; 
    28         this.findOnlyOne = findOneOnly; 
    2942        //defunits = new ArrayDeque<DefUnit>(4); 
    3043    } 

  • trunk/dtool/src/dtool/refmodel/IScope.java

    r804 r866  
    77 
    88/** 
    9  * Gives access to the scope's DefUnits, and to super scopes.  
     9 * A scope is a list of declarations and or statements. 
     10 * Some of those declarations may be DefUnits. 
     11 * A scope may have several super scopes, and has exactly one outer scope. 
     12 * A scope may be a statement block, which has different lookup rules.  
    1013 */ 
    11 public interface IScope extends IScopeAdaptable { 
     14public interface IScope { 
    1215 
    1316 
    …… 
    2427    IScope getModuleScope(); 
    2528     
     29    /** Returns whether this scope has a sequential lookup,  
     30     * such as statement scopes. */ 
     31    boolean hasSequentialLookup(); 
     32     
    2633    /** For UI printing */ 
    2734    String toStringAsElement(); 
     35 
     36 
    2837} 

  • trunk/dtool/src/dtool/refmodel/PrefixDefUnitSearch.java

    r833 r866  
    22 
    33import static melnorme.miscutil.Assert.assertFail; 
     4import static melnorme.miscutil.Assert.assertNotNull; 
     5 
     6import java.util.Iterator; 
    47 
    58import org.eclipse.dltk.core.ISourceModule; 
    …… 
    3841 
    3942    public PrefixDefUnitSearch(PrefixSearchOptions searchOptions, 
     43            IScopeNode refScope, int refOffset, 
    4044            IDefUnitMatchAccepter defUnitAccepter) { 
    41         super(null); 
     45        super(refScope, refOffset); 
    4246        this.searchOptions = searchOptions; 
    4347        this.defUnitAccepter = defUnitAccepter; 
    …… 
    6165    @Override 
    6266    public void addMatch(DefUnit defUnit) { 
    63         defUnitAccepter.accept(defUnit, searchOptions); 
    64     } 
    65      
     67        if(notOccluded(defUnit)) 
     68            defUnitAccepter.accept(defUnit, searchOptions); 
     69    } 
     70     
     71    public boolean notOccluded(DefUnit newDefUnit) { 
     72        Iterator<DefUnit> iter = defUnitAccepter.getResultsIterator(); 
     73        while (iter.hasNext()) { 
     74            DefUnit defunit = iter.next(); 
     75            if(defunit.toStringAsElement().equals(newDefUnit.toStringAsElement())) 
     76                return false; 
     77        } 
     78        return true; 
     79    }; 
     80 
    6681    public static interface IDefUnitMatchAccepter { 
    6782        void accept(DefUnit defUnit, PrefixSearchOptions searchOptions); 
     83 
     84        Iterator<DefUnit> getResultsIterator(); 
    6885    } 
    6986 
    …… 
    111128        // : Do actual completion search 
    112129         
     130         
     131        ASTNeoNode node = ASTNodeFinder.findElement(neoModule, offset); 
     132        assertNotNull(node); 
     133        session.invokeNode = node; 
    113134        PrefixSearchOptions searchOptions = new PrefixSearchOptions(); 
    114         PrefixDefUnitSearch search = new PrefixDefUnitSearch(searchOptions, defUnitAccepter); 
    115          
    116         ASTNeoNode node = ASTNodeFinder.findElement(neoModule, offset); 
    117         session.invokeNode = node; 
    118         search.refScope = NodeUtil.getScopeNode(node); 
     135        IScopeNode refScope = NodeUtil.getScopeNode(node); 
     136        PrefixDefUnitSearch search; 
     137        search = new PrefixDefUnitSearch(searchOptions, 
     138               refScope, offset, defUnitAccepter); 
     139 
    119140         
    120141        if(node instanceof NamedReference)  { 
    …… 
    124145                RefIdentifier refIdent = (RefIdentifier) node; 
    125146                if(!parserAdapter.isQualifiedDotFixSearch) { 
    126                     setupPrefixedSearch2(searchOptions,  
    127                             offset, refIdent.getOffset(), refIdent.name); 
     147                    setupPrefixedSearch(searchOptions, offset,  
     148                            refIdent.getOffset(), refIdent.name); 
    128149                } 
    129150            } else if(node instanceof CommonRefQualified) { 
    …… 
    137158                 
    138159                if(offset <= idEndPos) { 
    139                     setupPrefixedSearch2(searchOptions,  
    140                             offset, refTpl.getOffset(), refTpl.name); 
     160                    setupPrefixedSearch(searchOptions, offset,  
     161                            refTpl.getOffset(), refTpl.name); 
    141162                } else if(lastToken.value == TOK.TOKnot) { 
    142163                    return "Invalid Context:" + lastToken; 
    …… 
    144165            } else if(node instanceof RefModule) { 
    145166                RefModule refMod = (RefModule) node; 
    146                 setupPrefixedSearch2(searchOptions, offset, refMod.getOffset(), refMod.toStringAsElement()); 
     167                setupPrefixedSearch(searchOptions, offset,  
     168                        refMod.getOffset(), refMod.toStringAsElement()); 
    147169            } else if (node instanceof RefImportSelection) { 
    148170                RefImportSelection refImpSel = (RefImportSelection) node; 
    149                 setupPrefixedSearch2(searchOptions, offset, refImpSel.getOffset(), refImpSel.name); 
     171                setupPrefixedSearch(searchOptions, offset,  
     172                        refImpSel.getOffset(), refImpSel.name); 
    150173            } else { 
    151174                assertFail(); 
    …… 
    158181        } 
    159182         
    160         // Determine a scope for an unprefix search 
     183        // Since picked node was not a reference, 
     184        // determine appropriate scope search parameters 
    161185        IScopeNode scope; 
    162186        while(true) { 
     187            assertNotNull(node); 
    163188            scope = isValidCompletionScope(node); 
    164189            if(scope != null) 
    …… 
    175200    } 
    176201 
    177     private static void setupPrefixedSearch2(PrefixSearchOptions searchOptions,  
     202    private static void setupPrefixedSearch(PrefixSearchOptions searchOptions,  
    178203            final int offset, int nameOffset, String name) { 
    179204        int prefixLen = offset - nameOffset;  

  • trunk/dtool/src/dtool/refmodel/ReferenceResolver.java

    r758 r866  
    1414import dtool.ast.d