Attachment #144291 for bug #235102

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 235102
Collapse All | Expand All




    }

    public static CsmType createSimpleType(CsmClassifier cls, OffsetDescriptor offs) {
        return getProvider().createType(cls, new TypeDescriptor(false, 0, 0, 0), offs);
    }

    /**

     * @return new type
     */
    public static CsmType createConstType(CsmType orig) {
        return getProvider().createType(orig, new TypeDescriptor(true, TypeDescriptor.getReferenceType(orig), orig.getPointerDepth(), orig.getArrayDepth()));
    }

    /**

        } else {
            arrDepth = Math.max(arrDepth - 1, 0);
        }
        return getProvider().createType(type, new TypeDescriptor(type.isConst(), TypeDescriptor.getReferenceType(type), ptrDepth, arrDepth));
    }

    //@Immutable


    //@Immutable
    public static final class TypeDescriptor {
        
        public static final int NON_REFERENCE = 0;
        
        public static final int REFERENCE = 1;
        
        public static final int RVALUE_REFERENCE = 2;
        
        public static int getReferenceType(CsmType type) {
            if (type.isRValueReference()) {
                return RVALUE_REFERENCE;
            } else if (type.isReference()) {
                return REFERENCE;
            }
            return NON_REFERENCE;
        }
        
        public static int getReferenceType(TypeDescriptor td) {
            return td._reference;
        }

        
        private final boolean _const;
        private final int _reference;
        private final int _ptrDepth;
        private final int _arrDepth;

        public TypeDescriptor(boolean _const, int _reference, int _ptrDepth, int _arrDepth) {
            this._const = _const;
            this._reference = _reference;
            this._ptrDepth = _ptrDepth;

        }

        public boolean isReference() {
            return _reference > 0;
        }
        
        public boolean isRValueReference() {
            return _reference > 1;
        }
    }





import org.netbeans.cnd.api.lexer.CppTokenId;
import org.netbeans.modules.cnd.api.model.CsmClass;
import org.netbeans.modules.cnd.api.model.CsmClassifier;
import org.netbeans.modules.cnd.api.model.CsmConstructor;
import org.netbeans.modules.cnd.api.model.CsmDeclaration;
import org.netbeans.modules.cnd.api.model.CsmField;
import org.netbeans.modules.cnd.api.model.CsmFile;
import org.netbeans.modules.cnd.api.model.CsmFunction;
import org.netbeans.modules.cnd.api.model.CsmFunctional;
import org.netbeans.modules.cnd.api.model.CsmMember;
import org.netbeans.modules.cnd.api.model.CsmObject;
import org.netbeans.modules.cnd.api.model.CsmOffsetableDeclaration;
import org.netbeans.modules.cnd.api.model.CsmParameter;
import org.netbeans.modules.cnd.api.model.CsmSpecializationParameter;
import org.netbeans.modules.cnd.api.model.CsmTemplate;
import org.netbeans.modules.cnd.api.model.CsmTemplateParameter;
import org.netbeans.modules.cnd.api.model.CsmType;
import org.netbeans.modules.cnd.api.model.CsmVariable;
import org.netbeans.modules.cnd.api.model.deep.CsmReturnStatement;

import org.netbeans.modules.cnd.api.model.deep.CsmStatement.Kind;
import org.netbeans.modules.cnd.api.model.services.CsmClassifierResolver;
import org.netbeans.modules.cnd.api.model.services.CsmInheritanceUtilities;
import org.netbeans.modules.cnd.api.model.services.CsmInstantiationProvider;
import org.netbeans.modules.cnd.api.model.services.CsmMacroExpansion;
import org.netbeans.modules.cnd.api.model.services.CsmTypes;
import org.netbeans.modules.cnd.api.model.util.CsmBaseUtilities;
import org.netbeans.modules.cnd.api.model.util.CsmKindUtilities;
import org.netbeans.modules.cnd.api.model.util.UIDs;
import org.netbeans.modules.cnd.completion.cplusplus.CsmFinderFactory;
import org.netbeans.modules.cnd.completion.cplusplus.ext.CsmCompletionQuery.Context;
import org.netbeans.modules.cnd.completion.csm.CompletionUtilities;
import org.netbeans.modules.cnd.completion.csm.CsmContext;
import org.netbeans.modules.cnd.completion.csm.CsmContextUtilities;
import org.netbeans.modules.cnd.completion.csm.CsmOffsetResolver;
import org.netbeans.modules.cnd.completion.csm.CsmOffsetUtilities;
import org.netbeans.modules.cnd.completion.impl.xref.FileReferencesContext;
import org.netbeans.modules.cnd.modelutil.CsmUtilities;
import org.netbeans.modules.editor.NbEditorUtilities;
import org.netbeans.spi.editor.completion.CompletionItem;
import org.netbeans.spi.editor.completion.CompletionProvider;
import org.openide.filesystems.FileObject;
import org.openide.loaders.DataObject;
import org.openide.util.Pair;

/**
 *

    /** Filter the list of the methods (usually returned from
     * Finder.findMethods()) or the list of the constructors
     * by the given parameter specification.
     * @param ctx - completion context
     * @param methodList list of the methods. They should have the same
     *   name but in fact they don't have to.
     * @param exp - instantiation params
     * @param parmTypes parameter types specification. If set to null, no filtering
     *   is performed and the same list is returned. If a particular
     * @param acceptMoreParameters useful for code completion to get
     *   even the methods with more parameters.
     */
    static <T extends CsmFunctional> Collection<T> filterMethods(Context ctx, 
                                                                 Collection<T> methodList, 
                                                                 CsmCompletionExpression exp,
                                                                 List parmTypeList,
                                                                 boolean acceptMoreParameters, 
                                                                 boolean acceptIfSameNumberParams
    ) {
        Collection<T> result = filterMethods(methodList, parmTypeList, acceptMoreParameters, acceptIfSameNumberParams, false);
        if (result.size() > 1) {
            // it seems that this call couldn't filter anything

            
            // perform more accurate filtering if it is a strict request (for navigation probably)
            if (!acceptMoreParameters && acceptIfSameNumberParams) {
                result = accurateFilterMethods(ctx, result, exp, parmTypeList);
            }
        }
        return result;

     * Please note: This method is designed to be called after preliminary filtering.
     *              But this is not a necessary requirement.
     * 
     * @param ctx - completion context
     * @param methods
     * @param paramTypes
     * 
     * @return candidates
     */
    private static <T extends CsmFunctional> Collection<T> accurateFilterMethods(Context ctx, Collection<T> methods, CsmCompletionExpression exp, List paramTypes) {
        if (methods.size() <= 1) {
            return methods;
        }

                    break;
                }
            }
            
            boolean validCandidate = true;
            
            if (CsmKindUtilities.isTemplate(candidate.function)) {
                // we should check if this function is viable
                CsmType retType = extractFunctionType(ctx, Arrays.asList(candidate.function), exp, paramTypes);
                CsmClassifier cls = retType != null ? CsmBaseUtilities.getClassifier(retType, ctx.getContextFile(), ctx.getEndOffset(), true) : null;
                validCandidate = (cls != null && cls.isValid());
            }

            if (validCandidate) {
                prev = candidate;
                result.add(candidate.function);
            }
        }
        
        return result.isEmpty() ? methods : result;

        }
        return false;
    }
    
    static CsmType extractFunctionType(Context context, Collection<? extends CsmFunctional> mtdList, CsmCompletionExpression genericNameExp, List<CsmType> typeList) {
        CsmType out = null;
        if (mtdList.isEmpty()) {
            return null;
        }
        for (CsmFunctional fun : mtdList) {
            CsmObject entity = fun;

            if (CsmKindUtilities.isConstructor(entity)) {
                entity = ((CsmConstructor) entity).getContainingClass();
            }

            if (CsmKindUtilities.isTemplate(entity)) {
                CsmObject inst = createInstantiation(context, (CsmTemplate) entity, genericNameExp, typeList);                    
                if (CsmKindUtilities.isFunction(inst) || CsmKindUtilities.isClassifier(inst)) {
                    entity = inst;
                }
            }
            
            if (CsmKindUtilities.isFunctional(entity)) {
                out = ((CsmFunctional) entity).getReturnType();
            } else if (CsmKindUtilities.isClassifier(entity)) {
                out = CsmCompletion.createType((CsmClassifier) entity, 0, 0, 0, false);
            }
            if (out != null) {
                break;
            }
        }
        return out;
    }        
    
    static CsmObject createInstantiation(Context context, CsmTemplate template, CsmCompletionExpression exp, List<CsmType> typeList) {
        if (exp != null || !typeList.isEmpty()) {
            CsmInstantiationProvider ip = CsmInstantiationProvider.getDefault();
            List<CsmSpecializationParameter> params = new ArrayList<CsmSpecializationParameter>();        
            params.addAll(collectInstantiationParameters(context, ip, exp));
            if (CsmKindUtilities.isFunction(template)) {
                params.addAll(collectInstantiationParameters(ip, (CsmFunction)template, params.size(), typeList));
            }
            if (!params.isEmpty()) {
                return ip.instantiate(template, params);
            }
        }
        return null;
    }   
    
    static List<CsmSpecializationParameter> collectInstantiationParameters(Context context, CsmInstantiationProvider ip, CsmCompletionExpression exp) {
        if (exp != null) {
            List<CsmSpecializationParameter> params = new ArrayList<CsmSpecializationParameter>();
            if (exp.getExpID() == CsmCompletionExpression.GENERIC_TYPE) {
                int paramsNumber = exp.getParameterCount() - 1;
                for (int i = 0; i < paramsNumber; i++) {
                    CsmCompletionExpression paramInst = exp.getParameter(i + 1);
                    if (paramInst != null) {
                        switch (paramInst.getExpID()) {
                            case CsmCompletionExpression.CONSTANT:
                                params.add(ip.createExpressionBasedSpecializationParameter(paramInst.getTokenText(0),
                                        context.getContextFile(), paramInst.getTokenOffset(0), paramInst.getTokenOffset(0) + paramInst.getTokenLength(0)));
                                break;
                            default:
                                CsmType type = null;
                                
                                if (!isExpression(paramInst)) {
                                    type = context.resolveType(paramInst);                                
                                    if (type != null) {
                                        List<? extends CompletionItem> candidates = context.resolveNextExp(paramInst);
                                        if (candidates != null && (candidates.get(0) instanceof CsmResultItem.VariableResultItem)) {
                                            type = null;
                                        }
                                    }
                                }
                                
                                if (type != null) {
                                    params.add(ip.createTypeBasedSpecializationParameter(type));
                                } else {
                                    RenderedExpression renderedExpression = renderExpression(paramInst);
                                    params.add(ip.createExpressionBasedSpecializationParameter(
                                            renderedExpression.text,
                                            context.getContextFile(), 
                                            renderedExpression.startOffset, 
                                            renderedExpression.endOffset
                                    ));
                                }
                            }
                    } else {
                        break;
                    }
                }
            }
            return params;
        }
        return Collections.emptyList();
    }
    
    static List<CsmSpecializationParameter> collectInstantiationParameters(CsmInstantiationProvider ip, CsmFunction function, int explicitelyMappedSize, List<CsmType> typeList) {            
        if (CsmKindUtilities.isTemplate(function)) {
            List<CsmSpecializationParameter> result = new ArrayList<CsmSpecializationParameter>();
            
            CsmTemplate template = (CsmTemplate) function;                
            List<CsmTemplateParameter> templateParams = template.getTemplateParameters();
            
            if (templateParams.size() > explicitelyMappedSize) {
                Map<CsmTemplateParameter, CsmType> paramsMap = gatherTemplateParamsMap(function, typeList);
                
                for (int i = explicitelyMappedSize; i < templateParams.size(); i++) {
                    CsmTemplateParameter param = templateParams.get(i);
                    CsmType mappedType = paramsMap.get(param);
                    if (mappedType != null) {
                        result.add(ip.createTypeBasedSpecializationParameter(mappedType));
                    } else {
                        // error
                        return result;
                    }
                }
            }
            
            return result;
        }
        return Collections.emptyList();
    }
    
    static Map<CsmTemplateParameter, CsmType> gatherTemplateParamsMap(CsmFunction function, List<CsmType> typeList) {
        assert CsmKindUtilities.isTemplate(function) : "Attempt to gather template parameters map from non-template function"; // NOI18N
        CsmTemplate template = (CsmTemplate) function;
        
        Map<CsmTemplateParameter, CsmType> map = new HashMap<CsmTemplateParameter, CsmType>();
        
        for (CsmTemplateParameter templateParam : template.getTemplateParameters()) {
            int paramIndex = 0;                
            for (CsmParameter param : function.getParameters()) {
                if (paramIndex >= typeList.size()) {
                    break;
                }
                CsmType paramType = param.getType();
                CsmType calculatedType = calcTypeFromParameter(templateParam, paramType, typeList.get(paramIndex));
                if (calculatedType != null) {
                     map.put(templateParam, calculatedType);
                }
                paramIndex++;
            }
        }
        
        return map;
    }
    
    static CsmType calcTypeFromParameter(CsmTemplateParameter templateParam, CsmType paramType, CsmType passedType) {
        if (paramType != null) {
            CsmClassifier cls = paramType.getClassifier();
            if (cls != null && cls.getQualifiedName().toString().equals(templateParam.getQualifiedName().toString())) {
                boolean hasChanges = false;
                
                boolean newConst = false;
                int newReference = CsmTypes.TypeDescriptor.NON_REFERENCE;
                int newPtrDepth = 0;
                int newArrayDepth = 0;
                
                CsmType underlyingType = CsmUtilities.iterateTypeChain(passedType, new CsmUtilities.ConstantPredicate<CsmType>(false));
                
                if (paramType.isConst()) {
                    if (underlyingType.isConst()) {
                        hasChanges = true;
                        newConst = false;
                    } else {
                        return null;
                    }
                }
                
                if (paramType.isPointer()) {
                    if (paramType.getPointerDepth() <= underlyingType.getPointerDepth()) {
                        hasChanges = true;
                        newPtrDepth = underlyingType.getPointerDepth() - paramType.getPointerDepth();
                    } else {
                        return null;
                    }
                }
                
                if (paramType.isReference()) {
                    if (underlyingType.isReference()) {
                        hasChanges = true;
                        newReference = CsmTypes.TypeDescriptor.NON_REFERENCE;
                    } else {
                        return null;
                    }
                }
                
                if (paramType.isRValueReference()) {
                    if (underlyingType.isRValueReference()) {
                        hasChanges = true;
                        newReference = CsmTypes.TypeDescriptor.NON_REFERENCE;
                    } else {
                        return null;
                    }
                }
                
                if (hasChanges) {
                    CsmTypes.TypeDescriptor td = new CsmTypes.TypeDescriptor(
                            newConst, 
                            newReference, 
                            newPtrDepth, 
                            newArrayDepth
                    );
                    
                    return CsmTypes.createType(underlyingType, td);
                }
                
                return passedType;
            }                
        }
        return null;
    }   
    
    static RenderedExpression renderExpression(CsmCompletionExpression expr) {
        if (expr == null) {
            return null;
        }            
        switch (expr.getExpID()) {
            case CsmCompletionExpression.GENERIC_TYPE: {
                StringBuilder sb = new StringBuilder();
                int startExpOffset = expr.getTokenOffset(0);
                int endExpOffset = startExpOffset;
                
                for (int paramIndex = 0; paramIndex < expr.getParameterCount(); paramIndex++) {
                    RenderedExpression current = renderExpression(expr.getParameter(paramIndex));
                    
                    sb.append(current.text);
                    
                    if (paramIndex > 0) {
                        if (paramIndex < expr.getParameterCount() - 1) {
                            sb.append(","); // NOI18N
                        } else {
                            sb.append(">"); // NOI18N
                        }
                        endExpOffset++;
                    } else {
                        sb.append(expr.getTokenText(0));
                    }
                    
                    endExpOffset = current.endOffset;
                }
                
                return new RenderedExpression(sb.toString(), startExpOffset, endExpOffset);
            }
            
            case CsmCompletionExpression.UNARY_OPERATOR:
            case CsmCompletionExpression.OPERATOR:
            case CsmCompletionExpression.SCOPE: {
                StringBuilder sb = new StringBuilder();
                int startExpOffset = -1;
                int endExprOffset = -1;

                int paramCount = expr.getParameterCount();
                int tokenCount = expr.getTokenCount();
                int paramIndex = 0;
                int tokenIndex = 0;
                
                RenderedExpression renderedParam = null;
                RenderedExpression renderedToken = null;                    
                boolean lastWasParam = false;
                boolean lastWasToken = false;
                
                boolean entityChanged = true;
                
                while (entityChanged) {
                    entityChanged = false;
                                            
                    if (renderedParam == null && paramIndex < paramCount) {
                        renderedParam = renderExpression(expr.getParameter(paramIndex));
                        paramIndex++;
                    }
                    
                    if (renderedToken == null && tokenIndex < tokenCount) {
                        renderedToken = new RenderedExpression(
                            expr.getTokenText(tokenIndex).toString(), 
                            expr.getTokenOffset(tokenIndex), 
                            expr.getTokenOffset(tokenIndex) + expr.getTokenLength(tokenIndex)
                        );
                        tokenIndex++;
                    }
                    
                    RenderedExpression chosenExpression;
                    
                    if (renderedParam != null && renderedToken != null) {
                        if (renderedParam.startOffset < renderedToken.startOffset) {
                            chosenExpression = renderedParam;
                        } else {
                            chosenExpression = renderedToken;
                        }
                    } else if (renderedToken == null) {
                        chosenExpression = renderedParam;
                    } else {
                        chosenExpression = renderedToken;
                    }
                    
                    if (chosenExpression != null) {
                        if (chosenExpression == renderedParam) {
                            renderedParam = null;
                            entityChanged = !lastWasParam;
                            lastWasParam = true;
                            lastWasToken = false;
                        } else {
                            renderedToken = null;
                            entityChanged = !lastWasToken;
                            lastWasToken = true;
                            lastWasParam = false;
                        }
                        
                        if (entityChanged) {
                            sb.append(chosenExpression.text);
                            if (startExpOffset == -1) {
                                startExpOffset = chosenExpression.startOffset;
                            }
                            endExprOffset = chosenExpression.endOffset;
                        }
                    }
                }
                
                return new RenderedExpression(sb.toString(), startExpOffset, endExprOffset);
            }
            
            default: {
                return new RenderedExpression(
                        expr.getTokenText(0), 
                        expr.getTokenOffset(0), 
                        expr.getTokenOffset(0) + expr.getTokenLength(0)
                );
            }
        }
    }    

    CsmType findExactVarType(CsmFile file, String var, int docPos, FileReferencesContext refContext) {
        if (file == null) {

            }
        }
        return null;
    }    
    
    private static boolean isExpression(CsmCompletionExpression expression) {
        return expression.getExpID() == CsmCompletionExpression.OPERATOR ||
               expression.getExpID() == CsmCompletionExpression.UNARY_OPERATOR;
    }    
    
    private int findLCurlsNumberBeforPosition(String s, int pos) {
        int cursor = -1;

    public void changedUpdate(DocumentEvent e) {
        this.lastSeparatorOffset = -1;
    }
    
    
    static class RenderedExpression {
        
        public final String text;
        
        public final int startOffset;
        
        public final int endOffset;

        public RenderedExpression(String text, int startOffset, int endOffset) {
            this.text = text;
            this.startOffset = startOffset;
            this.endOffset = endOffset;
        }

        @Override
        public String toString() {
            return text + "[" + startOffset + "," + endOffset + "]"; // NOI18N
        }
    }    
}




import org.netbeans.modules.cnd.api.model.CsmField;
import org.netbeans.modules.cnd.api.model.CsmFile;
import org.netbeans.modules.cnd.api.model.CsmFunction;
import org.netbeans.modules.cnd.api.model.CsmFunctionPointerClassifier;
import org.netbeans.modules.cnd.api.model.CsmFunctionPointerType;
import org.netbeans.modules.cnd.api.model.CsmFunctionPointerClassifier;
import org.netbeans.modules.cnd.api.model.CsmFunctional;
import org.netbeans.modules.cnd.api.model.CsmInheritance;
import org.netbeans.modules.cnd.api.model.CsmInstantiation;

import org.netbeans.modules.cnd.api.model.services.CsmSelect;
import org.netbeans.modules.cnd.api.model.services.CsmSelect.CsmFilter;
import org.netbeans.modules.cnd.api.model.services.CsmSelect.CsmFilterBuilder;
import org.netbeans.modules.cnd.api.model.services.CsmTypes;
import org.netbeans.modules.cnd.api.model.util.CsmBaseUtilities;
import org.netbeans.modules.cnd.api.model.util.CsmKindUtilities;
import org.netbeans.modules.cnd.api.model.util.CsmSortUtilities;

import org.netbeans.spi.editor.completion.CompletionItem;
import org.openide.text.CloneableEditorSupport;
import org.openide.util.NbBundle;
import org.openide.util.Pair;

/**
 *

            this.instantiateTypes = instantiateTypes;
            this.instantiations = instantiations;
        }
        
        CsmFile getContextFile() {
            return contextFile;
        }
        
        int getEndOffset() {
            return endOffset;
        }

        private int convertOffset(int pos) {
            return sup.doc2context(pos);

            return out;
        }

        private CsmType extractFunctionType(Collection<? extends CsmFunctional> mtdList, CsmCompletionExpression genericNameExp, List<CsmType> typeList) {
            CsmType out = null;
            if (mtdList.isEmpty()) {
                return null;
            }
            for (CsmFunctional fun : mtdList) {
                CsmObject entity = fun;

                if (CsmKindUtilities.isConstructor(entity)) {
                    entity = ((CsmConstructor) entity).getContainingClass();
                }

                if (CsmKindUtilities.isTemplate(entity)) {
                    CsmObject inst = createInstantiation((CsmTemplate) entity, genericNameExp, typeList);                    
                    if (CsmKindUtilities.isFunction(inst) || CsmKindUtilities.isClassifier(inst)) {
                        entity = inst;
                    }
                }
                
                if (CsmKindUtilities.isFunctional(entity)) {
                    out = ((CsmFunctional) entity).getReturnType();
                } else if (CsmKindUtilities.isClassifier(entity)) {
                    out = CsmCompletion.createType((CsmClassifier) entity, 0, 0, 0, false);
                }
                if (out != null) {
                    break;
                }
            }
            return out;
        }

        /*private CsmClassifier resolveTemplateParameter(CsmClassifier cls, CsmType type) {
        if (cls instanceof CsmClassifierBasedTemplateParameter) {
        CsmClassifierBasedTemplateParameter tp = (CsmClassifierBasedTemplateParameter) cls;

        }
        return cls;
        }*/
        CsmType resolveType(CsmCompletionExpression exp) {
            CsmType typ = exp.getCachedType();
            if (typ == null) {
                Context ctx = (Context) clone();

                    exp.cacheType(typ);
                    // restore old
                    ctx.compResolver.setResolveScope(old);
                }        
            }
            return typ;
        }

        List<? extends CompletionItem> resolveNextExp(CsmCompletionExpression exp) {
            Context ctx = (Context) clone();
            ctx.setFindType(false);
            // when resolve type use full scope of search
            QueryScope old = ctx.compResolver.setResolveScope(QueryScope.GLOBAL_QUERY);
            try {
                if (ctx.resolveExp(exp, true)) {
                    if (ctx.result != null && !ctx.result.getItems().isEmpty()) {
                        return ctx.result.getItems();
                    }
                }
            } finally {
                // restore old
                ctx.compResolver.setResolveScope(old);
            }
            return null;
        }        

        private boolean isProjectBeeingParsed() {
            return CsmCompletionQuery.this.isProjectBeeingParsed(openingSource);
        }

                        lastType = typ;
                        CsmClassifier cls = getClassifier(lastType, contextFile, endOffset);
                        if (cls != null && CsmKindUtilities.isTemplate(cls)) {
                            CsmObject obj = CompletionSupport.createInstantiation(this, (CsmTemplate)cls, item, Collections.<CsmType>emptyList());
                            if (obj != null && CsmKindUtilities.isClass(obj)) {
                                lastType = CsmCompletion.createType((CsmClass)obj, 0, 0, 0, false);
                            }

                                if (!mtdList.isEmpty()) {
                                    List<CsmType> typeList = getTypeList(item, 0);
                                    // check exact overloaded operator
                                    Collection<CsmFunction> filtered = CompletionSupport.filterMethods(this, mtdList, null, typeList, false, false);
                                    if (filtered.size() > 0) {
                                        mtdList = filtered;
                                        lastType = CompletionSupport.extractFunctionType(this, mtdList, null, typeList);
                                    } else if (item.getParameterCount() > 1) {
                                        CsmType type0 = resolveType(item.getParameter(0));
                                        CsmType type1 = resolveType(item.getParameter(1));

                                        }
                                        if (cls != null) {
                                            if (CsmKindUtilities.isTemplate(cls) && genericNameExp != null) {
                                                CsmObject inst = CompletionSupport.createInstantiation(this, (CsmTemplate)cls, genericNameExp, Collections.<CsmType>emptyList());
                                                if (CsmKindUtilities.isClassifier(inst)) {
                                                    cls = (CsmClassifier) inst;
                                                }

                            }
                            String parmStr = "*"; // NOI18N
                            List<CsmType> typeList = getTypeList(item, 1);
                            Collection<CsmFunctional> filtered = CompletionSupport.filterMethods(this, mtdList, genericNameExp, typeList, methodOpen, true);
                            if (filtered.size() > 0) {
                                mtdList = filtered;
                                parmStr = formatTypeList(typeList, methodOpen);

                                            formatType(lastType, true, true, false) + mtdName + '(' + parmStr + ')',
                                            item, endOffset, 0, 0, isProjectBeeingParsed(), contextElement, instantiateTypes);
                                } else {
                                    lastType = CompletionSupport.extractFunctionType(this, mtdList, genericNameExp, typeList);
                                    staticOnly = false;
                                }
                            } else {

            }
            return false;
        }        
        
        private CsmObject createInstantiation(CsmTemplate template, CsmCompletionExpression exp, List<CsmType> typeList) {
            if (exp != null || !typeList.isEmpty()) {
                CsmInstantiationProvider ip = CsmInstantiationProvider.getDefault();
                List<CsmSpecializationParameter> params = new ArrayList<CsmSpecializationParameter>();        
                params.addAll(collectInstantiationParameters(ip, exp));
                if (CsmKindUtilities.isFunction(template)) {
                    params.addAll(collectInstantiationParameters(ip, (CsmFunction)template, params.size(), typeList));
                }
                if (!params.isEmpty()) {
                    return ip.instantiate(template, params);
                }
            }
            return null;
        }   
        
        private List<CsmSpecializationParameter> collectInstantiationParameters(CsmInstantiationProvider ip, CsmCompletionExpression exp) {
            if (exp != null) {
                List<CsmSpecializationParameter> params = new ArrayList<CsmSpecializationParameter>();
                if (exp.getExpID() == CsmCompletionExpression.GENERIC_TYPE) {
                    int paramsNumber = exp.getParameterCount() - 1;
                    for (int i = 0; i < paramsNumber; i++) {
                        CsmCompletionExpression paramInst = exp.getParameter(i + 1);
                        if (paramInst != null) {
                            switch (paramInst.getExpID()) {
                                case CsmCompletionExpression.CONSTANT:
                                    params.add(ip.createExpressionBasedSpecializationParameter(paramInst.getTokenText(0),
                                            contextFile, paramInst.getTokenOffset(0), paramInst.getTokenOffset(0) + paramInst.getTokenLength(0)));
                                    break;
                                default:
                                    CsmType type = resolveType(paramInst);
                                    if (type != null) {
                                        params.add(ip.createTypeBasedSpecializationParameter(type));
                                    } else {
                                        RenderedExpression renderedExpression = renderExpression(paramInst);
                                        params.add(ip.createExpressionBasedSpecializationParameter(
                                                renderedExpression.text,
                                                contextFile, 
                                                renderedExpression.startOffset, 
                                                renderedExpression.endOffset
                                        ));
                                    }
                                }
                        } else {
                            break;
                        }
                    }
                }
                return params;
            }
            return Collections.emptyList();
        }
        
        private List<CsmSpecializationParameter> collectInstantiationParameters(CsmInstantiationProvider ip, CsmFunction function, int explicitelyMappedSize, List<CsmType> typeList) {            
            if (CsmKindUtilities.isTemplate(function)) {
                List<CsmSpecializationParameter> result = new ArrayList<CsmSpecializationParameter>();
                
                CsmTemplate template = (CsmTemplate) function;                
                List<CsmTemplateParameter> templateParams = template.getTemplateParameters();
                
                if (templateParams.size() > explicitelyMappedSize) {
                    Map<CsmTemplateParameter, CsmType> paramsMap = gatherTemplateParamsMap(function, typeList);
                    
                    for (int i = explicitelyMappedSize; i < templateParams.size(); i++) {
                        CsmTemplateParameter param = templateParams.get(i);
                        CsmType mappedType = paramsMap.get(param);
                        if (mappedType != null) {
                            result.add(ip.createTypeBasedSpecializationParameter(mappedType));
                        } else {
                            // error
                            return result;
                        }
                    }
                }
                
                return result;
            }
            return Collections.emptyList();
        }
        
        private Map<CsmTemplateParameter, CsmType> gatherTemplateParamsMap(CsmFunction function, List<CsmType> typeList) {
            assert CsmKindUtilities.isTemplate(function) : "Attempt to gather template parameters map from non-template function"; // NOI18N
            CsmTemplate template = (CsmTemplate) function;
            
            Map<CsmTemplateParameter, CsmType> map = new HashMap<CsmTemplateParameter, CsmType>();
            
            for (CsmTemplateParameter templateParam : template.getTemplateParameters()) {
                int paramIndex = 0;                
                for (CsmParameter param : function.getParameters()) {
                    if (paramIndex >= typeList.size()) {
                        break;
                    }
                    CsmType paramType = param.getType();
                    if (paramType != null) {
                        CsmClassifier cls = paramType.getClassifier();
                        if (cls != null) {
                            if (cls.getQualifiedName().toString().equals(templateParam.getQualifiedName().toString())) {
                                map.put(templateParam, typeList.get(paramIndex));
                            }
                        }
                    }
                    paramIndex++;
                }
            }
            
            return map;
        }
        
        private RenderedExpression renderExpression(CsmCompletionExpression expr) {
            if (expr == null) {
                return null;
            }            
            switch (expr.getExpID()) {
                case CsmCompletionExpression.SCOPE: {
                    StringBuilder sb = new StringBuilder();
                    int startExpOffset = -1;
                    int endExprOffset = -1;

                    int paramCount = expr.getParameterCount();
                    int tokenCount = expr.getTokenCount();
                    int paramIndex = 0;
                    int tokenIndex = 0;
                    
                    RenderedExpression renderedParam = null;
                    RenderedExpression renderedToken = null;                    
                    boolean lastWasParam = false;
                    boolean lastWasToken = false;
                    
                    boolean entityChanged = true;
                    
                    while (entityChanged) {
                        entityChanged = false;
                                                
                        if (renderedParam == null && paramIndex < paramCount) {
                            renderedParam = renderExpression(expr.getParameter(paramIndex));
                            paramIndex++;
                        }
                        
                        if (renderedToken == null && tokenIndex < tokenCount) {
                            renderedToken = new RenderedExpression(
                                expr.getTokenText(tokenIndex).toString(), 
                                expr.getTokenOffset(tokenIndex), 
                                expr.getTokenOffset(tokenIndex) + expr.getTokenLength(tokenIndex)
                            );
                            tokenIndex++;
                        }
                        
                        RenderedExpression chosenExpression;
                        
                        if (renderedParam != null && renderedToken != null) {
                            if (renderedParam.startOffset < renderedToken.startOffset) {
                                chosenExpression = renderedParam;
                            } else {
                                chosenExpression = renderedToken;
                            }
                        } else if (renderedToken == null) {
                            chosenExpression = renderedParam;
                        } else {
                            chosenExpression = renderedToken;
                        }
                        
                        if (chosenExpression != null) {
                            if (chosenExpression == renderedParam) {
                                renderedParam = null;
                                entityChanged = !lastWasParam;
                                lastWasParam = true;
                                lastWasToken = false;
                            } else {
                                renderedToken = null;
                                entityChanged = !lastWasToken;
                                lastWasToken = true;
                                lastWasParam = false;
                            }
                            
                            if (entityChanged) {
                                sb.append(chosenExpression.text);
                                if (startExpOffset == -1) {
                                    startExpOffset = chosenExpression.startOffset;
                                }
                                endExprOffset = chosenExpression.endOffset;
                            }
                        }
                    }
                    
                    return new RenderedExpression(sb.toString(), startExpOffset, endExprOffset);
                }
                
                default: {
                    return new RenderedExpression(
                            expr.getTokenText(0), 
                            expr.getTokenOffset(0), 
                            expr.getTokenOffset(0) + expr.getTokenLength(0)
                    );
                }
            }
        }
        
        private class RenderedExpression {
            
            public final String text;
            
            public final int startOffset;
            
            public final int endOffset;

            public RenderedExpression(String text, int startOffset, int endOffset) {
                this.text = text;
                this.startOffset = startOffset;
                this.endOffset = endOffset;
            }

            @Override
            public String toString() {
                return text + "[" + startOffset + "," + endOffset + "]"; // NOI18N
            }
        }

        private CsmType findBuiltInFunctionReturnType(String mtdName, int tokenOffset) {
            CsmType out = null;




        }
        return new Type(type, instantiation);       
    }
    
    public static CsmType createType(CsmType type, List<CsmInstantiation> instantiations) {
        for (CsmInstantiation instantiation : instantiations) {
            type = createType(type, instantiation);
        }
        return type;
    }
    
//    public static CsmType resolveTemplateParameterType(CsmType type, Map<CsmTemplateParameter, CsmSpecializationParameter> mapping) {
//        if (CsmKindUtilities.isTemplateParameterType(type)) {
//            LOG.log(Level.FINE, "Instantiation.resolveTemplateParameter {0}; mapping={1}\n", new Object[]{type.getText(), instantiation.getTemplateDeclaration().getName()});
//            CsmType resolvedType = resolveTemplateParameterType(((CsmTemplateParameterType) type).getParameter(), new MapHierarchy<>(mapping));
//            if (resolvedType != null) {
//                return resolvedType;
//            }            
//        }
//        return type;
//    }    
    
    public static CsmType resolveTemplateParameterType(CsmType type, CsmInstantiation instantiation) {
        if (CsmKindUtilities.isTemplateParameterType(type)) {
            LOG.log(Level.FINE, "Instantiation.resolveTemplateParameter {0}; mapping={1}\n", new Object[]{type.getText(), instantiation.getTemplateDeclaration().getName()});
            MapHierarchy<CsmTemplateParameter, CsmSpecializationParameter> mapping = new MapHierarchy<>(instantiation.getMapping());
            CsmType resolvedType = resolveTemplateParameterType(((CsmTemplateParameterType) type).getParameter(), mapping);
            if (resolvedType != null) {
                return resolvedType;
            }
        }
        return type;
    }    
    
    public static CsmType resolveTemplateParameterType(CsmTemplateParameter templateParameter, Map<CsmTemplateParameter, CsmSpecializationParameter> mapping) {
        return resolveTemplateParameterType(templateParameter, new MapHierarchy<>(mapping));

Lines 132-142 Link Here

(-)a/cnd.modelimpl/src/org/netbeans/modules/cnd/modelimpl/csm/NestedType.java (-5 / +5 lines)
132	classifier = getNestedClassifier(memberResolver, parentClassifier, getOwnText());	132	classifier = getNestedClassifier(memberResolver, parentClassifier, getOwnText());
133	}	133	}
134	}	134	}
135	if (!CsmBaseUtilities.isValid(classifier)) {	135	// if (!CsmBaseUtilities.isValid(classifier)) {
136	// try to resolve qualified name, not through the parent classifier	136	// // try to resolve qualified name, not through the parent classifier
137	List<CharSequence> fqn = getFullQName();	137	// List<CharSequence> fqn = getFullQName();
138	classifier = renderClassifier(fqn.toArray(new CharSequence[fqn.size()]));	138	// classifier = renderClassifier(fqn.toArray(new CharSequence[fqn.size()]));
139	}	139	// }
140	_setClassifier(classifier);	140	_setClassifier(classifier);
141	}	141	}
142	if (isInstantiation() && CsmKindUtilities.isTemplate(classifier) && !((CsmTemplate)classifier).getTemplateParameters().isEmpty()) {	142	if (isInstantiation() && CsmKindUtilities.isTemplate(classifier) && !((CsmTemplate)classifier).getTemplateParameters().isEmpty()) {

Lines 981-986 Link Here

(-)a/cnd.modelimpl/src/org/netbeans/modules/cnd/modelimpl/csm/TypeImpl.java (+4 lines)
981		981
982	protected CsmClassifier _getClassifier() {	982	protected CsmClassifier _getClassifier() {
983	CsmClassifier classifier = null;	983	CsmClassifier classifier = null;
		984	boolean clearClassifier = false;
		985	if (clearClassifier) {
		986	classifierUID = null;
		987	}
984	if (classifierUID != null) {	988	if (classifierUID != null) {
985	classifier = UIDCsmConverter.UIDtoDeclaration(classifierUID);	989	classifier = UIDCsmConverter.UIDtoDeclaration(classifierUID);
986	} else {	990	} else {




                for (CsmTemplateParameter param : orderedParamsList) {
                    Map<CsmTemplateParameter, CsmSpecializationParameter> newMapping = new HashMap<CsmTemplateParameter, CsmSpecializationParameter>();
                    CsmSpecializationParameter spec = inst.getMapping().get(param);
                    /*if(CsmKindUtilities.isExpressionBasedSpecalizationParameter(spec)) {
                        Object o = eval(((CsmExpressionBasedSpecializationParameter) spec).getText().toString(), inst.getTemplateDeclaration(), mapHierarchy);
                        CsmSpecializationParameter newSpec = ExpressionBasedSpecializationParameterImpl.create(o.toString(),
                                spec.getContainingFile(), spec.getStartOffset(), spec.getEndOffset());
                        newMapping.put(param, newSpec);
                    } else*/ {
                        newMapping.put(param, spec);
                    }
                    mapping.putAll(newMapping);




import org.netbeans.modules.cnd.modelutil.CsmUtilities;
import org.netbeans.modules.cnd.spi.model.services.CsmExpressionEvaluatorProvider;
import org.netbeans.modules.cnd.utils.CndCollectionUtils;
import org.openide.util.Pair;

/**
 * Service that provides template instantiations

    public CsmObject instantiate(CsmTemplate template, CsmInstantiation instantiation) {
        return instantiate(template, instantiation, true);        
    }
     
    public CsmObject instantiate(CsmTemplate template, CsmInstantiation instantiation, boolean specialize) {
        return instantiate(template, null, 0, instantiation, specialize);
    }

    }
    
    private CsmClassifier specialize(CsmClassifier classifier, CsmFile contextFile, int contextOffset) {
        List<Pair<CsmSpecializationParameter, List<CsmInstantiation>>> params = getInstantiationParams(classifier);
        CsmClassifier specialization = null;
        if (CsmKindUtilities.isTemplate(classifier)) {
            List<CsmTemplateParameter> templateParams = ((CsmTemplate) classifier).getTemplateParameters();

                    // try to find full specialization of class
                    CsmClass cls = (CsmClass) classifier;
                    StringBuilder fqn = new StringBuilder(cls.getUniqueName());
                    fqn.append(Instantiation.getInstantiationCanonicalText(getPlainParams(params)));
                    
                    for (CsmProject proj : projects) {
                        CsmDeclaration decl = proj.findDeclaration(fqn.toString());

        return projects;
    }

    private static CsmClassifier findBestSpecialization(Collection<CsmOffsetableDeclaration> specializations, List<Pair<CsmSpecializationParameter, List<CsmInstantiation>>> params, final CsmClassifier cls) {
        // TODO : update

        CsmClassifier bestSpecialization = null;

        boolean variadic = false;
        
        List<Pair<CsmSpecializationParameter, List<CsmInstantiation>>> params2 = new ArrayList<Pair<CsmSpecializationParameter, List<CsmInstantiation>>>();
        for (Pair<CsmSpecializationParameter, List<CsmInstantiation>> pair : params) {
            CsmSpecializationParameter param = pair.first();
            if(CsmKindUtilities.isVariadicSpecalizationParameter(param)) {
                for (CsmSpecializationParameter arg : ((CsmVariadicSpecializationParameter)param).getArgs()) {
                    params2.add(Pair.of(arg, pair.second()));
                }
                variadic = true;
            } else {
                params2.add(pair);
            }
        }
        params = params2;

        if (!specializations.isEmpty()) {
            int bestMatch = 0;
            int paramsSize = 0;
            for (Pair<CsmSpecializationParameter, List<CsmInstantiation>> pair : params) {
                CsmSpecializationParameter param = pair.first();
                if(CsmKindUtilities.isVariadicSpecalizationParameter(param)) {
                    paramsSize += ((CsmVariadicSpecializationParameter)param).getArgs().size();
                } else {


            List<CharSequence> paramsText = new ArrayList<CharSequence>();
            List<CsmType> paramsType = new ArrayList<CsmType>();
            for (Pair<CsmSpecializationParameter, List<CsmInstantiation>> pair : params) {
                CsmSpecializationParameter param = pair.first();
                if (CsmKindUtilities.isTypeBasedSpecalizationParameter(param)) {
                    CsmType paramType = ((CsmTypeBasedSpecializationParameter) param).getType();
                    
                    if (CsmKindUtilities.isInstantiation(cls)) {
                        paramType = Instantiation.createType(paramType, pair.second());
//                        // Try to instantiate type with appropriate instantiations
//                        Iterator<CsmInstantiation> instIters = new Iterator() {
//
//                            private CsmInstantiation instantiation = (CsmInstantiation) cls;
//
//                            @Override
//                            public boolean hasNext() {
//                                return instantiation != null;
//                            }
//
//                            @Override
//                            public Object next() {
//                                CsmInstantiation res = instantiation;
//                                if (CsmKindUtilities.isInstantiation(instantiation.getTemplateDeclaration())) {
//                                    instantiation = (CsmInstantiation) instantiation.getTemplateDeclaration();
//                                } else {
//                                    instantiation = null;
//                                }
//                                return res;
//                            }
//
//                            @Override
//                            public void remove() {
//                                throw new UnsupportedOperationException("Not supported.");  // NOI18N
//                            }
//                        };
//                        
//                        CsmType instantiatedType = createTypeInstantiationForTypeParameter((CsmTypeBasedSpecializationParameter) param, instIters, 0);
////                        CsmType instantiatedType = null;
//                        
//                        if (instantiatedType != null) {
//                            // If success then it will be parameter type
//                            paramType = instantiatedType;
//                        } else {
//                            // If instantiation failed then create instantiation with the the full class isntantiation
//                            paramType = Instantiation.createType(paramType, (CsmInstantiation) cls);
//                        }
                    }
                    
                    paramsType.add(paramType);

                    if (specParams.size() == paramsSize) {
                        for (int i = 0; i < paramsSize - 1; i++) {
                            CsmSpecializationParameter specParam1 = specParams.get(i);
                            CsmSpecializationParameter param1 = params.get(i).first();
//                            for (int j = i + 1; j < paramsSize; j++) {
                            int j = i + 1;
                                CsmSpecializationParameter specParam2 = specParams.get(j);
                                CsmSpecializationParameter param2 = params.get(j).first();
                                if (specParam1.getText().toString().equals(specParam2.getText().toString())
                                        && param1.getText().toString().equals(param2.getText().toString())) {
                                    match += 1;

                                            CsmKindUtilities.isTypeBasedSpecalizationParameter(param1) &&
                                            CsmKindUtilities.isTypeBasedSpecalizationParameter(param2)) {
                                        CsmTypeBasedSpecializationParameter tbp1 = (CsmTypeBasedSpecializationParameter) param1;
                                        CsmType type1 = paramsType.get(i);
//                                        CsmType type1 = tbp1.getType();
//                                        if(CsmKindUtilities.isInstantiation(cls)) {
//                                            type1 = Instantiation.createType(tbp1.getType(), (Instantiation)cls);
//                                        }
                                        CsmClassifier tbsp1Cls = getClassifier(type1);
                                        if (tbsp1Cls != null) {
                                            CsmTypeBasedSpecializationParameter tbp2 = (CsmTypeBasedSpecializationParameter) param2;
                                            CsmType type2 = paramsType.get(j);
//                                            CsmType type2 = tbp2.getType();
//                                            if(CsmKindUtilities.isInstantiation(cls)) {
//                                                type2 = Instantiation.createType(tbp2.getType(), (Instantiation)cls);
//                                            }
                                            CsmClassifier tbsp2Cls = getClassifier(type2);
                                            if(tbsp2Cls != null) {
                                                if (tbsp1Cls.getQualifiedName().toString().equals(tbsp2Cls.getQualifiedName().toString())) {
                                                    match += 1;
                                                } else {
                                                    tbsp1Cls = CsmBaseUtilities.getOriginalClassifier(tbsp1Cls, param1.getContainingFile());
                                                    tbsp2Cls = CsmBaseUtilities.getOriginalClassifier(tbsp2Cls, param2.getContainingFile());
                                                    if (tbsp1Cls.getQualifiedName().toString().equals(tbsp2Cls.getQualifiedName().toString())) {
                                                        match += 1;
                                                    }
                                                }
                                            }
                                        }

                        }
                        for (int i = 0; i < paramsSize; i++) {
                            CsmSpecializationParameter specParam = specParams.get(i);
                            CsmSpecializationParameter param = params.get(i).first();
                            if (CsmKindUtilities.isTypeBasedSpecalizationParameter(specParam) &&
                                    CsmKindUtilities.isTypeBasedSpecalizationParameter(param)) {
                                CsmTypeBasedSpecializationParameter instSpecParam = (CsmTypeBasedSpecializationParameter)param;                                

        return ExpressionBasedSpecializationParameterImpl.create(expression, file, start, end);
    }
    
    public List<Pair<CsmSpecializationParameter, List<CsmInstantiation>>> getInstantiationParams(CsmObject o) {
        if (!CsmKindUtilities.isInstantiation(o)) {
            return Collections.emptyList();
        }
        long time = System.currentTimeMillis();
        List<Pair<CsmSpecializationParameter, List<CsmInstantiation>>> res = new ArrayList<Pair<CsmSpecializationParameter, List<CsmInstantiation>>>();
        CsmInstantiation i = (CsmInstantiation) o;
        Map<CsmTemplateParameter, CsmSpecializationParameter> m = i.getMapping();
        CsmOffsetableDeclaration decl = i.getTemplateDeclaration();

                for (CsmTemplateParameter tp : ((CsmTemplate)decl).getTemplateParameters()) {
                    CsmSpecializationParameter sp = m.get(tp);
                    if(sp != null) {
                        List<CsmInstantiation> insts = new ArrayList<>();
                        insts.add(i);
                        res.add(Pair.of(sp, insts));
                    }
                }
            }
        } else {
            // non first inst
            List<Pair<CsmSpecializationParameter, List<CsmInstantiation>>> sps = getInstantiationParams(decl);
            for (Pair<CsmSpecializationParameter, List<CsmInstantiation>> pair : sps) {
                CsmSpecializationParameter instParam = pair.first();
                List<CsmInstantiation> instantiations = pair.second();
                if (CsmKindUtilities.isTypeBasedSpecalizationParameter(instParam) &&
                        CsmKindUtilities.isTemplateParameterType(((CsmTypeBasedSpecializationParameter) instParam).getType())) {
                    CsmTemplateParameterType paramType = (CsmTemplateParameterType) ((CsmTypeBasedSpecializationParameter) instParam).getType();
                    CsmSpecializationParameter newTp = m.get(paramType.getParameter());
                    if (newTp != null && newTp != instParam) {
                        instantiations.clear();
                        res.add(Pair.of(newTp, instantiations));
                    } else {
                        res.add(pair);
                    }
                } else {
                    res.add(pair);
                }
                instantiations.add(i);
            }
        }
        time = System.currentTimeMillis() - time;

        return res;
    }    
    
    private List<CsmSpecializationParameter> getPlainParams(List<Pair<CsmSpecializationParameter, List<CsmInstantiation>>> instParams) {
        List<CsmSpecializationParameter> params = new ArrayList<>(instParams.size());
        for (Pair<CsmSpecializationParameter, List<CsmInstantiation>> pair : instParams) {
            params.add(pair.first());
        }
        return params;
    }
    
    private CsmClassForwardDeclaration findCsmClassForwardDeclaration(CsmScope scope, CsmClass cls) {
        if (scope != null) {
            if (CsmKindUtilities.isFile(scope)) {




import org.netbeans.modules.cnd.api.model.CsmTemplateParameterType;
import org.netbeans.modules.cnd.api.model.CsmType;
import org.netbeans.modules.cnd.api.model.CsmTypeBasedSpecializationParameter;
import org.netbeans.modules.cnd.api.model.deep.CsmExpression;
import org.netbeans.modules.cnd.api.model.services.CsmClassifierResolver;
import org.netbeans.modules.cnd.api.model.services.CsmInstantiationProvider;
import org.netbeans.modules.cnd.api.model.util.CsmKindUtilities;

 */
public class VariableProvider {
    private static final Logger LOG = Logger.getLogger(VariableProvider.class.getSimpleName());
    public static final int INFINITE_RECURSION = 16;

    private final int level;
    private CsmOffsetableDeclaration decl;

                            }
                        } else if (CsmKindUtilities.isTypeBasedSpecalizationParameter(spec)) {
                            CsmTypeBasedSpecializationParameter specParameter = (CsmTypeBasedSpecializationParameter) spec;
                            
// TODO: think about param decl and appropriate mapping (could be necessary if parameter is instantiation itself)
//                            CsmOffsetableDeclaration paramContextDecl = decl;
//                            MapHierarchy<CsmTemplateParameter, CsmSpecializationParameter> paramMapping = mapping;
//                            
//                            CsmType specParamType = specParameter.getType();
//                            CsmClassifier specParamCls = specParamType.getClassifier();
//                            if (CsmKindUtilities.isInstantiation(specParamCls) && CsmKindUtilities.isOffsetableDeclaration(specParamCls)) {
//                                paramContextDecl = (CsmOffsetableDeclaration) specParamCls;
//                                paramMapping = TemplateUtils.gatherMapping((CsmInstantiation) paramContextDecl);
//                            }
                            
                            Object eval = new ExpressionEvaluator(level+1).eval(specParameter.getText().toString(), decl, specParameter.getContainingFile(), specParameter.getStartOffset(), specParameter.getEndOffset(), mapping);
                            if (eval instanceof Integer) {
                                return (Integer) eval;

                    if (classMembers.hasNext()) {
                        CsmMember member = classMembers.next();
                        if(member.isStatic() && CsmKindUtilities.isField(member) && member.getName().toString().equals(variableName)) {
                            CsmExpression expr = ((CsmField)member).getInitialValue();
                            if(CsmKindUtilities.isInstantiation(member)) {
                                Object eval = new ExpressionEvaluator(level+1).eval(
                                        expr.getText().toString(), 
                                        member.getContainingClass(), 
                                        expr.getContainingFile(),
                                        expr.getStartOffset(),
                                        expr.getEndOffset(),
                                        getMapping((CsmInstantiation) member)
                                );
                                if (eval instanceof Integer) {
                                    return (Integer) eval;
                                }
                            } else if (expr != null) {
                                Object eval = new ExpressionEvaluator(level+1).eval(((CsmField)member).getInitialValue().getText().toString(), member.getContainingClass(), Collections.<CsmTemplateParameter, CsmSpecializationParameter>emptyMap());
                                if (eval instanceof Integer) {
                                    return (Integer) eval;

                    }
                }

                boolean executeSimpleResolution = false;// !(TraceFlags.EXPRESSION_EVALUATOR_DEEP_VARIABLE_PROVIDER && variableName.contains("<")); // NOI18N

                if (executeSimpleResolution) {
                    CsmObject o = null;

                                }
                            }

//                            if(CsmKindUtilities.isInstantiation(decl)) {
//                                type = Instantiation.createType(type, (Instantiation)decl);
//                            }

                            CsmClassifier originalClassifier = CsmClassifierResolver.getDefault().getOriginalClassifier(type.getClassifier(), decl.getContainingFile());
                            if (CsmKindUtilities.isTemplate(originalClassifier)) {

Lines 37-48 Link Here

(-)a/cnd.modelimpl/src/org/netbeans/modules/cnd/modelimpl/impl/services/evaluator/parser/Evaluator.g (-15 / +29 lines)
37	;	37	;
38		38
39	multExpr returns [int value]	39	multExpr returns [int value]
40	: e=atom {$value = $e.value;} (STAR e=atom {$value = $e.value;})	40	: e=unaryExpr {$value = $e.value;} (STAR e=unaryExpr {$value = $e.value;})
		41	;
		42
		43	unaryExpr returns [int value]
		44	: e=atom {$value = $e.value;}
		45	\| NOT e=unaryExpr {$value = ($e.value == 0 ? 1 : 0);}
41	;	46	;
42		47
43	atom returns [int value]	48	atom returns [int value]
44	: DECIMALINT {$value = (($DECIMALINT.text) == null) ? 0 : Integer.parseInt(($DECIMALINT.text).replaceAll("[a-z,A-Z,_].*", "")) ;}	49	:
45	\| id = qualified_id	50	DECIMALINT {$value = (($DECIMALINT.text) == null) ? 0 : Integer.parseInt(($DECIMALINT.text).replaceAll("[a-z,A-Z,_].*", "")) ;}
		51	\|
		52	(LITERAL_const)*
		53	id = qualified_id
46	{	54	{
47	$value = vp==null?0:vp.getValue($id.q);	55	$value = vp==null?0:vp.getValue($id.q);
48	//Integer v = (Integer)memory.get($IDENT.text);	56	//Integer v = (Integer)memory.get($IDENT.text);
Lines 69-79 Link Here
69	IDENT	77	IDENT
70	{q += $IDENT.text;}	78	{q += $IDENT.text;}
71	(	79	(
72	LESSTHAN	80	inner = balance_less_greater {q += $inner.s;}
73	{q += "<";}
74	(x=~GREATERTHAN {q += $x.text;})*
75	GREATERTHAN
76	{q += ">";}
77	)?	81	)?
78	)	82	)
79	;	83	;
Lines 84-90 Link Here
84	SCOPE { s += "::";}	88	SCOPE { s += "::";}
85	)?	89	)?
86	(	90	(
87	sp = scope_override_part	91	(IDENT (balance_less_greater)? SCOPE)=> sp = scope_override_part
88	{	92	{
89	s += ($sp.s != null) ? $sp.s : "";	93	s += ($sp.s != null) ? $sp.s : "";
90	}	94	}
Lines 98-120 Link Here
98	s += $IDENT.text;	102	s += $IDENT.text;
99	}	103	}
100	(	104	(
101	LESSTHAN	105	inner = balance_less_greater {s += $inner.s;}
102	{s += "<";}
103	(x=~GREATERTHAN {s += $x.text;})*
104	GREATERTHAN
105	{s += ">";}
106	)?	106	)?
107	SCOPE	107	SCOPE
108	{	108	{
109	s += "::";	109	s += "::";
110	}	110	}
111		111
112	((IDENT SCOPE) => sp = scope_override_part)?	112	((IDENT (balance_less_greater)? SCOPE)=> sp = scope_override_part)?
113	{	113	{
114	s += ($sp.s != null) ? $sp.s : "";	114	s += ($sp.s != null) ? $sp.s : "";
115	}	115	}
116	;	116	;
117		117
		118	balance_less_greater returns [String s = ""]
		119	:
		120	LESSTHAN {s += "<";}
		121	(
		122	(LESSTHAN)=> inner = balance_less_greater {s += $inner.s;}
		123	\|
		124	other = (~GREATERTHAN) {s += $other.text;}
		125	)*
		126	GREATERTHAN {s += ">";}
		127	;
		128
118	// Suppressing warnings "no lexer rule corresponding to token"	129	// Suppressing warnings "no lexer rule corresponding to token"
119	fragment IDENT: ' ';	130	fragment IDENT: ' ';
120	fragment DECIMALINT: ' ';	131	fragment DECIMALINT: ' ';
Lines 124-129 Link Here
124	fragment STAR: ' ';	135	fragment STAR: ' ';
125	fragment LESSTHAN: ' ';	136	fragment LESSTHAN: ' ';
126	fragment GREATERTHAN: ' ';	137	fragment GREATERTHAN: ' ';
		138	fragment NOT: ' ';
127		139
128	fragment SCOPE: ' ';	140	fragment SCOPE: ' ';
129		141
Lines 134-136 Link Here
134	fragment LITERAL_true: ' ';	146	fragment LITERAL_true: ' ';
135	fragment LITERAL_false: ' ';	147	fragment LITERAL_false: ' ';
136		148
		149	fragment LITERAL_const: ' ';
		150

Lines 66-71 Link Here

(-)a/cnd.modelimpl/src/org/netbeans/modules/cnd/modelimpl/util/MapHierarchy.java (+6 lines)
66	push(map);	66	push(map);
67	}	67	}
68		68
		69	public MapHierarchy(MapHierarchy<K, V> mapHierarchy) {
		70	for (Map<K, V> map : mapHierarchy.maps) {
		71	push(map);
		72	}
		73	}
		74
69	public void push(Map<K, V> map) {	75	public void push(Map<K, V> map) {
70	maps.push(map);	76	maps.push(map);
71	}	77	}




import org.netbeans.modules.cnd.utils.CndPathUtilities;
import org.netbeans.modules.cnd.utils.CndUtils;
import org.netbeans.modules.cnd.utils.FSPath;
import org.netbeans.modules.cnd.utils.MutableObject;
import org.netbeans.modules.editor.NbEditorUtilities;
import org.openide.awt.StatusDisplayer;
import org.openide.cookies.EditorCookie;

     * @return last type
     */
    public static CsmType iterateTypeChain(CsmType type, Predicate<CsmType> stopFilter) {
        return iterateTypeChain(type, stopFilter, 50);
    }
    
    /**
     * Iterates type chain until end is reached or stopFilter returned true
     * @param type from iterate should start
     * @param stopFilter
     * @param maxDepth - max number of iterations
     * @return last type
     */    
    public static CsmType iterateTypeChain(CsmType type, Predicate<CsmType> stopFilter, int maxDepth) {
        CsmType lastNestedType = type;
        
        Set<CsmType> antiLoop = new HashSet<CsmType>();
        
        while (type != null && !antiLoop.contains(type) && antiLoop.size() < maxDepth) {
            lastNestedType = type;
            
            if (stopFilter.check(type)) {

        }
        
        return lastNestedType;
    }    
    
//    public static CsmType checkPointerDepth(CsmType type, int depth, int maxIterations) {
//        final MutableObject<Integer> result = new MutableObject<>(0);
//        iterateTypeChain(type, new Predicate<CsmType>() {
//
//            @Override
//            public boolean check(CsmType value) {
//                if (value.isPointer()) {
//                    result.value += value.getPointerDepth();
//                }
//                return false;
//            }
//            
//        }, maxDepth);
//        return result.value;
//    }    
//
//    public static int checkReference(CsmType type, int maxDepth) {
//        final MutableObject<Integer> result = new MutableObject<>(0);
//        iterateTypeChain(type, new Predicate<CsmType>() {
//
//            @Override
//            public boolean check(CsmType value) {
//                if (value.isReference()) {
//                    if (value.isRValueReference()) {
//                        result.value = 2;
//                    }
//                    result.value = 1;
//                    return true;
//                }
//                return false;
//            }
//            
//        }, maxDepth);
//        return result.value;
//    }    
    
    //-----------------------------------------------------------------


Return to bug 235102

Lines 1227-1244 Link Here

(-)a/cnd.modelimpl/src/org/netbeans/modules/cnd/modelimpl/csm/Instantiation.java (-3 / +21 lines)
1227	}	1227	}
1228	return new Type(type, instantiation);	1228	return new Type(type, instantiation);
1229	}	1229	}
1230		1230
		1231	public static CsmType createType(CsmType type, List<CsmInstantiation> instantiations) {
		1232	for (CsmInstantiation instantiation : instantiations) {
		1233	type = createType(type, instantiation);
		1234	}
		1235	return type;
		1236	}
		1237
		1238	// public static CsmType resolveTemplateParameterType(CsmType type, Map<CsmTemplateParameter, CsmSpecializationParameter> mapping) {
		1239	// if (CsmKindUtilities.isTemplateParameterType(type)) {
		1240	// LOG.log(Level.FINE, "Instantiation.resolveTemplateParameter {0}; mapping={1}\n", new Object[]{type.getText(), instantiation.getTemplateDeclaration().getName()});
		1241	// CsmType resolvedType = resolveTemplateParameterType(((CsmTemplateParameterType) type).getParameter(), new MapHierarchy<>(mapping));
		1242	// if (resolvedType != null) {
		1243	// return resolvedType;
		1244	// }
		1245	// }
		1246	// return type;
		1247	// }
		1248
1231	public static CsmType resolveTemplateParameterType(CsmType type, CsmInstantiation instantiation) {	1249	public static CsmType resolveTemplateParameterType(CsmType type, CsmInstantiation instantiation) {
1232	if (CsmKindUtilities.isTemplateParameterType(type)) {	1250	if (CsmKindUtilities.isTemplateParameterType(type)) {
1233	LOG.log(Level.FINE, "Instantiation.resolveTemplateParameter {0}; mapping={1}\n", new Object[]{type.getText(), instantiation.getTemplateDeclaration().getName()});	1251	LOG.log(Level.FINE, "Instantiation.resolveTemplateParameter {0}; mapping={1}\n", new Object[]{type.getText(), instantiation.getTemplateDeclaration().getName()});
1234	MapHierarchy<CsmTemplateParameter, CsmSpecializationParameter> mapping = TemplateUtils.gatherMapping(instantiation);	1252	MapHierarchy<CsmTemplateParameter, CsmSpecializationParameter> mapping = new MapHierarchy<>(instantiation.getMapping());
1235	CsmType resolvedType = resolveTemplateParameterType(((CsmTemplateParameterType) type).getParameter(), mapping);	1253	CsmType resolvedType = resolveTemplateParameterType(((CsmTemplateParameterType) type).getParameter(), mapping);
1236	if (resolvedType != null) {	1254	if (resolvedType != null) {
1237	return resolvedType;	1255	return resolvedType;
1238	}	1256	}
1239	}	1257	}
1240	return type;	1258	return type;
1241	}	1259	}
1242		1260
1243	public static CsmType resolveTemplateParameterType(CsmTemplateParameter templateParameter, Map<CsmTemplateParameter, CsmSpecializationParameter> mapping) {	1261	public static CsmType resolveTemplateParameterType(CsmTemplateParameter templateParameter, Map<CsmTemplateParameter, CsmSpecializationParameter> mapping) {
1244	return resolveTemplateParameterType(templateParameter, new MapHierarchy<>(mapping));	1262	return resolveTemplateParameterType(templateParameter, new MapHierarchy<>(mapping));

Lines 212-223 Link Here

(-)a/cnd.modelimpl/src/org/netbeans/modules/cnd/modelimpl/impl/services/ExpressionEvaluator.java (-2 / +2 lines)
212	for (CsmTemplateParameter param : orderedParamsList) {	212	for (CsmTemplateParameter param : orderedParamsList) {
213	Map<CsmTemplateParameter, CsmSpecializationParameter> newMapping = new HashMap<CsmTemplateParameter, CsmSpecializationParameter>();	213	Map<CsmTemplateParameter, CsmSpecializationParameter> newMapping = new HashMap<CsmTemplateParameter, CsmSpecializationParameter>();
214	CsmSpecializationParameter spec = inst.getMapping().get(param);	214	CsmSpecializationParameter spec = inst.getMapping().get(param);
215	if(CsmKindUtilities.isExpressionBasedSpecalizationParameter(spec)) {	215	/*if(CsmKindUtilities.isExpressionBasedSpecalizationParameter(spec)) {
216	Object o = eval(((CsmExpressionBasedSpecializationParameter) spec).getText().toString(), inst.getTemplateDeclaration(), mapHierarchy);	216	Object o = eval(((CsmExpressionBasedSpecializationParameter) spec).getText().toString(), inst.getTemplateDeclaration(), mapHierarchy);
217	CsmSpecializationParameter newSpec = ExpressionBasedSpecializationParameterImpl.create(o.toString(),	217	CsmSpecializationParameter newSpec = ExpressionBasedSpecializationParameterImpl.create(o.toString(),
218	spec.getContainingFile(), spec.getStartOffset(), spec.getEndOffset());	218	spec.getContainingFile(), spec.getStartOffset(), spec.getEndOffset());
219	newMapping.put(param, newSpec);	219	newMapping.put(param, newSpec);
220	} else {	220	} else*/ {
221	newMapping.put(param, spec);	221	newMapping.put(param, spec);
222	}	222	}
223	mapping.putAll(newMapping);	223	mapping.putAll(newMapping);

Lines 69-75 Link Here

(-)a/cnd.api.model/src/org/netbeans/modules/cnd/api/model/services/CsmTypes.java (-6 / +31 lines)
69	}	69	}
70		70
71	public static CsmType createSimpleType(CsmClassifier cls, OffsetDescriptor offs) {	71	public static CsmType createSimpleType(CsmClassifier cls, OffsetDescriptor offs) {
72	return getProvider().createType(cls, new TypeDescriptor(false, false, 0, 0), offs);	72	return getProvider().createType(cls, new TypeDescriptor(false, 0, 0, 0), offs);
73	}	73	}
74		74
75	/**	75	/**
Lines 78-84 Link Here
78	* @return new type	78	* @return new type
79	*/	79	*/
80	public static CsmType createConstType(CsmType orig) {	80	public static CsmType createConstType(CsmType orig) {
81	return getProvider().createType(orig, new TypeDescriptor(true, orig.isReference(), orig.getPointerDepth(), orig.getArrayDepth()));	81	return getProvider().createType(orig, new TypeDescriptor(true, TypeDescriptor.getReferenceType(orig), orig.getPointerDepth(), orig.getArrayDepth()));
82	}	82	}
83		83
84	/**	84	/**
Lines 95-101 Link Here
95	} else {	95	} else {
96	arrDepth = Math.max(arrDepth - 1, 0);	96	arrDepth = Math.max(arrDepth - 1, 0);
97	}	97	}
98	return getProvider().createType(type, new TypeDescriptor(type.isConst(), type.isReference(), ptrDepth, arrDepth));	98	return getProvider().createType(type, new TypeDescriptor(type.isConst(), TypeDescriptor.getReferenceType(type), ptrDepth, arrDepth));
99	}	99	}
100		100
101	//@Immutable	101	//@Immutable
Lines 125-136 Link Here
125		125
126	//@Immutable	126	//@Immutable
127	public static final class TypeDescriptor {	127	public static final class TypeDescriptor {
		128
		129	public static final int NON_REFERENCE = 0;
		130
		131	public static final int REFERENCE = 1;
		132
		133	public static final int RVALUE_REFERENCE = 2;
		134
		135	public static int getReferenceType(CsmType type) {
		136	if (type.isRValueReference()) {
		137	return RVALUE_REFERENCE;
		138	} else if (type.isReference()) {
		139	return REFERENCE;
		140	}
		141	return NON_REFERENCE;
		142	}
		143
		144	public static int getReferenceType(TypeDescriptor td) {
		145	return td._reference;
		146	}
		147
		148
128	private final boolean _const;	149	private final boolean _const;
129	private final boolean _reference;	150	private final int _reference;
130	private final int _ptrDepth;	151	private final int _ptrDepth;
131	private final int _arrDepth;	152	private final int _arrDepth;
132		153
133	public TypeDescriptor(boolean _const, boolean _reference, int _ptrDepth, int _arrDepth) {	154	public TypeDescriptor(boolean _const, int _reference, int _ptrDepth, int _arrDepth) {
134	this._const = _const;	155	this._const = _const;
135	this._reference = _reference;	156	this._reference = _reference;
136	this._ptrDepth = _ptrDepth;	157	this._ptrDepth = _ptrDepth;
Lines 150-156 Link Here
150	}	171	}
151		172
152	public boolean isReference() {	173	public boolean isReference() {
153	return _reference;	174	return _reference > 0;
		175	}
		176
		177	public boolean isRValueReference() {
		178	return _reference > 1;
154	}	179	}
155	}	180	}
156		181

Lines 84-91 Link Here

(-)a/cnd.completion/src/org/netbeans/modules/cnd/completion/cplusplus/ext/CsmCompletionQuery.java (-256 / +37 lines)
84	import org.netbeans.modules.cnd.api.model.CsmField;	84	import org.netbeans.modules.cnd.api.model.CsmField;
85	import org.netbeans.modules.cnd.api.model.CsmFile;	85	import org.netbeans.modules.cnd.api.model.CsmFile;
86	import org.netbeans.modules.cnd.api.model.CsmFunction;	86	import org.netbeans.modules.cnd.api.model.CsmFunction;
		87	import org.netbeans.modules.cnd.api.model.CsmFunctionPointerClassifier;
87	import org.netbeans.modules.cnd.api.model.CsmFunctionPointerType;	88	import org.netbeans.modules.cnd.api.model.CsmFunctionPointerType;
88	import org.netbeans.modules.cnd.api.model.CsmFunctionPointerClassifier;
89	import org.netbeans.modules.cnd.api.model.CsmFunctional;	89	import org.netbeans.modules.cnd.api.model.CsmFunctional;
90	import org.netbeans.modules.cnd.api.model.CsmInheritance;	90	import org.netbeans.modules.cnd.api.model.CsmInheritance;
91	import org.netbeans.modules.cnd.api.model.CsmInstantiation;	91	import org.netbeans.modules.cnd.api.model.CsmInstantiation;
Lines 122-127 Link Here
122	import org.netbeans.modules.cnd.api.model.services.CsmSelect;	122	import org.netbeans.modules.cnd.api.model.services.CsmSelect;
123	import org.netbeans.modules.cnd.api.model.services.CsmSelect.CsmFilter;	123	import org.netbeans.modules.cnd.api.model.services.CsmSelect.CsmFilter;
124	import org.netbeans.modules.cnd.api.model.services.CsmSelect.CsmFilterBuilder;	124	import org.netbeans.modules.cnd.api.model.services.CsmSelect.CsmFilterBuilder;
		125	import org.netbeans.modules.cnd.api.model.services.CsmTypes;
125	import org.netbeans.modules.cnd.api.model.util.CsmBaseUtilities;	126	import org.netbeans.modules.cnd.api.model.util.CsmBaseUtilities;
126	import org.netbeans.modules.cnd.api.model.util.CsmKindUtilities;	127	import org.netbeans.modules.cnd.api.model.util.CsmKindUtilities;
127	import org.netbeans.modules.cnd.api.model.util.CsmSortUtilities;	128	import org.netbeans.modules.cnd.api.model.util.CsmSortUtilities;
Lines 141-146 Link Here
141	import org.netbeans.spi.editor.completion.CompletionItem;	142	import org.netbeans.spi.editor.completion.CompletionItem;
142	import org.openide.text.CloneableEditorSupport;	143	import org.openide.text.CloneableEditorSupport;
143	import org.openide.util.NbBundle;	144	import org.openide.util.NbBundle;
		145	import org.openide.util.Pair;
144		146
145	/**	147	/**
146	*	148	*
Lines 1145-1150 Link Here
1145	this.instantiateTypes = instantiateTypes;	1147	this.instantiateTypes = instantiateTypes;
1146	this.instantiations = instantiations;	1148	this.instantiations = instantiations;
1147	}	1149	}
		1150
		1151	CsmFile getContextFile() {
		1152	return contextFile;
		1153	}
		1154
		1155	int getEndOffset() {
		1156	return endOffset;
		1157	}
1148		1158
1149	private int convertOffset(int pos) {	1159	private int convertOffset(int pos) {
1150	return sup.doc2context(pos);	1160	return sup.doc2context(pos);
Lines 1398-1434 Link Here
1398	return out;	1408	return out;
1399	}	1409	}
1400		1410
1401	private CsmType extractFunctionType(Collection<? extends CsmFunctional> mtdList, CsmCompletionExpression genericNameExp, List<CsmType> typeList) {
1402	CsmType out = null;
1403	if (mtdList.isEmpty()) {
1404	return null;
1405	}
1406	for (CsmFunctional fun : mtdList) {
1407	CsmObject entity = fun;
1408
1409	if (CsmKindUtilities.isConstructor(entity)) {
1410	entity = ((CsmConstructor) entity).getContainingClass();
1411	}
1412
1413	if (CsmKindUtilities.isTemplate(entity)) {
1414	CsmObject inst = createInstantiation((CsmTemplate) entity, genericNameExp, typeList);
1415	if (CsmKindUtilities.isFunction(inst) \|\| CsmKindUtilities.isClassifier(inst)) {
1416	entity = inst;
1417	}
1418	}
1419
1420	if (CsmKindUtilities.isFunctional(entity)) {
1421	out = ((CsmFunctional) entity).getReturnType();
1422	} else if (CsmKindUtilities.isClassifier(entity)) {
1423	out = CsmCompletion.createType((CsmClassifier) entity, 0, 0, 0, false);
1424	}
1425	if (out != null) {
1426	break;
1427	}
1428	}
1429	return out;
1430	}
1431
1432	/*private CsmClassifier resolveTemplateParameter(CsmClassifier cls, CsmType type) {	1411	/*private CsmClassifier resolveTemplateParameter(CsmClassifier cls, CsmType type) {
1433	if (cls instanceof CsmClassifierBasedTemplateParameter) {	1412	if (cls instanceof CsmClassifierBasedTemplateParameter) {
1434	CsmClassifierBasedTemplateParameter tp = (CsmClassifierBasedTemplateParameter) cls;	1413	CsmClassifierBasedTemplateParameter tp = (CsmClassifierBasedTemplateParameter) cls;
Lines 1450-1456 Link Here
1450	}	1429	}
1451	return cls;	1430	return cls;
1452	}*/	1431	}*/
1453	private CsmType resolveType(CsmCompletionExpression exp) {	1432	CsmType resolveType(CsmCompletionExpression exp) {
1454	CsmType typ = exp.getCachedType();	1433	CsmType typ = exp.getCachedType();
1455	if (typ == null) {	1434	if (typ == null) {
1456	Context ctx = (Context) clone();	1435	Context ctx = (Context) clone();
Lines 1465-1475 Link Here
1465	exp.cacheType(typ);	1444	exp.cacheType(typ);
1466	// restore old	1445	// restore old
1467	ctx.compResolver.setResolveScope(old);	1446	ctx.compResolver.setResolveScope(old);
1468	}	1447	}
1469	}	1448	}
1470	return typ;	1449	return typ;
1471	}	1450	}
1472		1451
		1452	List<? extends CompletionItem> resolveNextExp(CsmCompletionExpression exp) {
		1453	Context ctx = (Context) clone();
		1454	ctx.setFindType(false);
		1455	// when resolve type use full scope of search
		1456	QueryScope old = ctx.compResolver.setResolveScope(QueryScope.GLOBAL_QUERY);
		1457	try {
		1458	if (ctx.resolveExp(exp, true)) {
		1459	if (ctx.result != null && !ctx.result.getItems().isEmpty()) {
		1460	return ctx.result.getItems();
		1461	}
		1462	}
		1463	} finally {
		1464	// restore old
		1465	ctx.compResolver.setResolveScope(old);
		1466	}
		1467	return null;
		1468	}
		1469
1473	private boolean isProjectBeeingParsed() {	1470	private boolean isProjectBeeingParsed() {
1474	return CsmCompletionQuery.this.isProjectBeeingParsed(openingSource);	1471	return CsmCompletionQuery.this.isProjectBeeingParsed(openingSource);
1475	}	1472	}
Lines 2066-2072 Link Here
2066	lastType = typ;	2063	lastType = typ;
2067	CsmClassifier cls = getClassifier(lastType, contextFile, endOffset);	2064	CsmClassifier cls = getClassifier(lastType, contextFile, endOffset);
2068	if (cls != null && CsmKindUtilities.isTemplate(cls)) {	2065	if (cls != null && CsmKindUtilities.isTemplate(cls)) {
2069	CsmObject obj = createInstantiation((CsmTemplate)cls, item, Collections.<CsmType>emptyList());	2066	CsmObject obj = CompletionSupport.createInstantiation(this, (CsmTemplate)cls, item, Collections.<CsmType>emptyList());
2070	if (obj != null && CsmKindUtilities.isClass(obj)) {	2067	if (obj != null && CsmKindUtilities.isClass(obj)) {
2071	lastType = CsmCompletion.createType((CsmClass)obj, 0, 0, 0, false);	2068	lastType = CsmCompletion.createType((CsmClass)obj, 0, 0, 0, false);
2072	}	2069	}
Lines 2158-2167 Link Here
2158	if (!mtdList.isEmpty()) {	2155	if (!mtdList.isEmpty()) {
2159	List<CsmType> typeList = getTypeList(item, 0);	2156	List<CsmType> typeList = getTypeList(item, 0);
2160	// check exact overloaded operator	2157	// check exact overloaded operator
2161	Collection<CsmFunction> filtered = CompletionSupport.filterMethods(mtdList, typeList, false, false);	2158	Collection<CsmFunction> filtered = CompletionSupport.filterMethods(this, mtdList, null, typeList, false, false);
2162	if (filtered.size() > 0) {	2159	if (filtered.size() > 0) {
2163	mtdList = filtered;	2160	mtdList = filtered;
2164	lastType = extractFunctionType(mtdList, null, typeList);	2161	lastType = CompletionSupport.extractFunctionType(this, mtdList, null, typeList);
2165	} else if (item.getParameterCount() > 1) {	2162	} else if (item.getParameterCount() > 1) {
2166	CsmType type0 = resolveType(item.getParameter(0));	2163	CsmType type0 = resolveType(item.getParameter(0));
2167	CsmType type1 = resolveType(item.getParameter(1));	2164	CsmType type1 = resolveType(item.getParameter(1));
Lines 2672-2678 Link Here
2672	}	2669	}
2673	if (cls != null) {	2670	if (cls != null) {
2674	if (CsmKindUtilities.isTemplate(cls) && genericNameExp != null) {	2671	if (CsmKindUtilities.isTemplate(cls) && genericNameExp != null) {
2675	CsmObject inst = createInstantiation((CsmTemplate)cls, genericNameExp, Collections.<CsmType>emptyList());	2672	CsmObject inst = CompletionSupport.createInstantiation(this, (CsmTemplate)cls, genericNameExp, Collections.<CsmType>emptyList());
2676	if (CsmKindUtilities.isClassifier(inst)) {	2673	if (CsmKindUtilities.isClassifier(inst)) {
2677	cls = (CsmClassifier) inst;	2674	cls = (CsmClassifier) inst;
2678	}	2675	}
Lines 2690-2696 Link Here
2690	}	2687	}
2691	String parmStr = "*"; // NOI18N	2688	String parmStr = "*"; // NOI18N
2692	List<CsmType> typeList = getTypeList(item, 1);	2689	List<CsmType> typeList = getTypeList(item, 1);
2693	Collection<CsmFunctional> filtered = CompletionSupport.filterMethods(mtdList, typeList, methodOpen, true);	2690	Collection<CsmFunctional> filtered = CompletionSupport.filterMethods(this, mtdList, genericNameExp, typeList, methodOpen, true);
2694	if (filtered.size() > 0) {	2691	if (filtered.size() > 0) {
2695	mtdList = filtered;	2692	mtdList = filtered;
2696	parmStr = formatTypeList(typeList, methodOpen);	2693	parmStr = formatTypeList(typeList, methodOpen);
Lines 2701-2707 Link Here
2701	formatType(lastType, true, true, false) + mtdName + '(' + parmStr + ')',	2698	formatType(lastType, true, true, false) + mtdName + '(' + parmStr + ')',
2702	item, endOffset, 0, 0, isProjectBeeingParsed(), contextElement, instantiateTypes);	2699	item, endOffset, 0, 0, isProjectBeeingParsed(), contextElement, instantiateTypes);
2703	} else {	2700	} else {
2704	lastType = extractFunctionType(mtdList, genericNameExp, typeList);	2701	lastType = CompletionSupport.extractFunctionType(this, mtdList, genericNameExp, typeList);
2705	staticOnly = false;	2702	staticOnly = false;
2706	}	2703	}
2707	} else {	2704	} else {
Lines 2833-3054 Link Here
2833	}	2830	}
2834	return false;	2831	return false;
2835	}	2832	}
2836
2837	private CsmObject createInstantiation(CsmTemplate template, CsmCompletionExpression exp, List<CsmType> typeList) {
2838	if (exp != null \|\| !typeList.isEmpty()) {
2839	CsmInstantiationProvider ip = CsmInstantiationProvider.getDefault();
2840	List<CsmSpecializationParameter> params = new ArrayList<CsmSpecializationParameter>();
2841	params.addAll(collectInstantiationParameters(ip, exp));
2842	if (CsmKindUtilities.isFunction(template)) {
2843	params.addAll(collectInstantiationParameters(ip, (CsmFunction)template, params.size(), typeList));
2844	}
2845	if (!params.isEmpty()) {
2846	return ip.instantiate(template, params);
2847	}
2848	}
2849	return null;
2850	}
2851
2852	private List<CsmSpecializationParameter> collectInstantiationParameters(CsmInstantiationProvider ip, CsmCompletionExpression exp) {
2853	if (exp != null) {
2854	List<CsmSpecializationParameter> params = new ArrayList<CsmSpecializationParameter>();
2855	if (exp.getExpID() == CsmCompletionExpression.GENERIC_TYPE) {
2856	int paramsNumber = exp.getParameterCount() - 1;
2857	for (int i = 0; i < paramsNumber; i++) {
2858	CsmCompletionExpression paramInst = exp.getParameter(i + 1);
2859	if (paramInst != null) {
2860	switch (paramInst.getExpID()) {
2861	case CsmCompletionExpression.CONSTANT:
2862	params.add(ip.createExpressionBasedSpecializationParameter(paramInst.getTokenText(0),
2863	contextFile, paramInst.getTokenOffset(0), paramInst.getTokenOffset(0) + paramInst.getTokenLength(0)));
2864	break;
2865	default:
2866	CsmType type = resolveType(paramInst);
2867	if (type != null) {
2868	params.add(ip.createTypeBasedSpecializationParameter(type));
2869	} else {
2870	RenderedExpression renderedExpression = renderExpression(paramInst);
2871	params.add(ip.createExpressionBasedSpecializationParameter(
2872	renderedExpression.text,
2873	contextFile,
2874	renderedExpression.startOffset,
2875	renderedExpression.endOffset
2876	));
2877	}
2878	}
2879	} else {
2880	break;
2881	}
2882	}
2883	}
2884	return params;
2885	}
2886	return Collections.emptyList();
2887	}
2888
2889	private List<CsmSpecializationParameter> collectInstantiationParameters(CsmInstantiationProvider ip, CsmFunction function, int explicitelyMappedSize, List<CsmType> typeList) {
2890	if (CsmKindUtilities.isTemplate(function)) {
2891	List<CsmSpecializationParameter> result = new ArrayList<CsmSpecializationParameter>();
2892
2893	CsmTemplate template = (CsmTemplate) function;
2894	List<CsmTemplateParameter> templateParams = template.getTemplateParameters();
2895
2896	if (templateParams.size() > explicitelyMappedSize) {
2897	Map<CsmTemplateParameter, CsmType> paramsMap = gatherTemplateParamsMap(function, typeList);
2898
2899	for (int i = explicitelyMappedSize; i < templateParams.size(); i++) {
2900	CsmTemplateParameter param = templateParams.get(i);
2901	CsmType mappedType = paramsMap.get(param);
2902	if (mappedType != null) {
2903	result.add(ip.createTypeBasedSpecializationParameter(mappedType));
2904	} else {
2905	// error
2906	return result;
2907	}
2908	}
2909	}
2910
2911	return result;
2912	}
2913	return Collections.emptyList();
2914	}
2915
2916	private Map<CsmTemplateParameter, CsmType> gatherTemplateParamsMap(CsmFunction function, List<CsmType> typeList) {
2917	assert CsmKindUtilities.isTemplate(function) : "Attempt to gather template parameters map from non-template function"; // NOI18N
2918	CsmTemplate template = (CsmTemplate) function;
2919
2920	Map<CsmTemplateParameter, CsmType> map = new HashMap<CsmTemplateParameter, CsmType>();
2921
2922	for (CsmTemplateParameter templateParam : template.getTemplateParameters()) {
2923	int paramIndex = 0;
2924	for (CsmParameter param : function.getParameters()) {
2925	if (paramIndex >= typeList.size()) {
2926	break;
2927	}
2928	CsmType paramType = param.getType();
2929	if (paramType != null) {
2930	CsmClassifier cls = paramType.getClassifier();
2931	if (cls != null) {
2932	if (cls.getQualifiedName().toString().equals(templateParam.getQualifiedName().toString())) {
2933	map.put(templateParam, typeList.get(paramIndex));
2934	}
2935	}
2936	}
2937	paramIndex++;
2938	}
2939	}
2940
2941	return map;
2942	}
2943
2944	private RenderedExpression renderExpression(CsmCompletionExpression expr) {
2945	if (expr == null) {
2946	return null;
2947	}
2948	switch (expr.getExpID()) {
2949	case CsmCompletionExpression.SCOPE: {
2950	StringBuilder sb = new StringBuilder();
2951	int startExpOffset = -1;
2952	int endExprOffset = -1;
2953
2954	int paramCount = expr.getParameterCount();
2955	int tokenCount = expr.getTokenCount();
2956	int paramIndex = 0;
2957	int tokenIndex = 0;
2958
2959	RenderedExpression renderedParam = null;
2960	RenderedExpression renderedToken = null;
2961	boolean lastWasParam = false;
2962	boolean lastWasToken = false;
2963
2964	boolean entityChanged = true;
2965
2966	while (entityChanged) {
2967	entityChanged = false;
2968
2969	if (renderedParam == null && paramIndex < paramCount) {
2970	renderedParam = renderExpression(expr.getParameter(paramIndex));
2971	paramIndex++;
2972	}
2973
2974	if (renderedToken == null && tokenIndex < tokenCount) {
2975	renderedToken = new RenderedExpression(
2976	expr.getTokenText(tokenIndex).toString(),
2977	expr.getTokenOffset(tokenIndex),
2978	expr.getTokenOffset(tokenIndex) + expr.getTokenLength(tokenIndex)
2979	);
2980	tokenIndex++;
2981	}
2982
2983	RenderedExpression chosenExpression;
2984
2985	if (renderedParam != null && renderedToken != null) {
2986	if (renderedParam.startOffset < renderedToken.startOffset) {
2987	chosenExpression = renderedParam;
2988	} else {
2989	chosenExpression = renderedToken;
2990	}
2991	} else if (renderedToken == null) {
2992	chosenExpression = renderedParam;
2993	} else {
2994	chosenExpression = renderedToken;
2995	}
2996
2997	if (chosenExpression != null) {
2998	if (chosenExpression == renderedParam) {
2999	renderedParam = null;
3000	entityChanged = !lastWasParam;
3001	lastWasParam = true;
3002	lastWasToken = false;
3003	} else {
3004	renderedToken = null;
3005	entityChanged = !lastWasToken;
3006	lastWasToken = true;
3007	lastWasParam = false;
3008	}
3009
3010	if (entityChanged) {
3011	sb.append(chosenExpression.text);
3012	if (startExpOffset == -1) {
3013	startExpOffset = chosenExpression.startOffset;
3014	}
3015	endExprOffset = chosenExpression.endOffset;
3016	}
3017	}
3018	}
3019
3020	return new RenderedExpression(sb.toString(), startExpOffset, endExprOffset);
3021	}
3022
3023	default: {
3024	return new RenderedExpression(
3025	expr.getTokenText(0),
3026	expr.getTokenOffset(0),
3027	expr.getTokenOffset(0) + expr.getTokenLength(0)
3028	);
3029	}
3030	}
3031	}
3032
3033	private class RenderedExpression {
3034
3035	public final String text;
3036
3037	public final int startOffset;
3038
3039	public final int endOffset;
3040
3041	public RenderedExpression(String text, int startOffset, int endOffset) {
3042	this.text = text;
3043	this.startOffset = startOffset;
3044	this.endOffset = endOffset;
3045	}
3046
3047	@Override
3048	public String toString() {
3049	return text + "[" + startOffset + "," + endOffset + "]"; // NOI18N
3050	}
3051	}
3052		2833
3053	private CsmType findBuiltInFunctionReturnType(String mtdName, int tokenOffset) {	2834	private CsmType findBuiltInFunctionReturnType(String mtdName, int tokenOffset) {
3054	CsmType out = null;	2835	CsmType out = null;

Lines 120-125 Link Here

(-)a/cnd.modelimpl/src/org/netbeans/modules/cnd/modelimpl/impl/services/InstantiationProviderImpl.java (-66 / +95 lines)
120	import org.netbeans.modules.cnd.modelutil.CsmUtilities;	120	import org.netbeans.modules.cnd.modelutil.CsmUtilities;
121	import org.netbeans.modules.cnd.spi.model.services.CsmExpressionEvaluatorProvider;	121	import org.netbeans.modules.cnd.spi.model.services.CsmExpressionEvaluatorProvider;
122	import org.netbeans.modules.cnd.utils.CndCollectionUtils;	122	import org.netbeans.modules.cnd.utils.CndCollectionUtils;
		123	import org.openide.util.Pair;
123		124
124	/**	125	/**
125	* Service that provides template instantiations	126	* Service that provides template instantiations
Lines 211-217 Link Here
211	public CsmObject instantiate(CsmTemplate template, CsmInstantiation instantiation) {	212	public CsmObject instantiate(CsmTemplate template, CsmInstantiation instantiation) {
212	return instantiate(template, instantiation, true);	213	return instantiate(template, instantiation, true);
213	}	214	}
214		215
215	public CsmObject instantiate(CsmTemplate template, CsmInstantiation instantiation, boolean specialize) {	216	public CsmObject instantiate(CsmTemplate template, CsmInstantiation instantiation, boolean specialize) {
216	return instantiate(template, null, 0, instantiation, specialize);	217	return instantiate(template, null, 0, instantiation, specialize);
217	}	218	}
Lines 483-489 Link Here
483	}	484	}
484		485
485	private CsmClassifier specialize(CsmClassifier classifier, CsmFile contextFile, int contextOffset) {	486	private CsmClassifier specialize(CsmClassifier classifier, CsmFile contextFile, int contextOffset) {
486	List<CsmSpecializationParameter> params = getInstantiationParams(classifier);	487	List<Pair<CsmSpecializationParameter, List<CsmInstantiation>>> params = getInstantiationParams(classifier);
487	CsmClassifier specialization = null;	488	CsmClassifier specialization = null;
488	if (CsmKindUtilities.isTemplate(classifier)) {	489	if (CsmKindUtilities.isTemplate(classifier)) {
489	List<CsmTemplateParameter> templateParams = ((CsmTemplate) classifier).getTemplateParameters();	490	List<CsmTemplateParameter> templateParams = ((CsmTemplate) classifier).getTemplateParameters();
Lines 493-499 Link Here
493	// try to find full specialization of class	494	// try to find full specialization of class
494	CsmClass cls = (CsmClass) classifier;	495	CsmClass cls = (CsmClass) classifier;
495	StringBuilder fqn = new StringBuilder(cls.getUniqueName());	496	StringBuilder fqn = new StringBuilder(cls.getUniqueName());
496	fqn.append(Instantiation.getInstantiationCanonicalText(params));	497	fqn.append(Instantiation.getInstantiationCanonicalText(getPlainParams(params)));
497		498
498	for (CsmProject proj : projects) {	499	for (CsmProject proj : projects) {
499	CsmDeclaration decl = proj.findDeclaration(fqn.toString());	500	CsmDeclaration decl = proj.findDeclaration(fqn.toString());
Lines 651-670 Link Here
651	return projects;	652	return projects;
652	}	653	}
653		654
654	private static CsmClassifier findBestSpecialization(Collection<CsmOffsetableDeclaration> specializations, List<CsmSpecializationParameter> params, final CsmClassifier cls) {	655	private static CsmClassifier findBestSpecialization(Collection<CsmOffsetableDeclaration> specializations, List<Pair<CsmSpecializationParameter, List<CsmInstantiation>>> params, final CsmClassifier cls) {
655	// TODO : update	656	// TODO : update
656		657
657	CsmClassifier bestSpecialization = null;	658	CsmClassifier bestSpecialization = null;
658		659
659	boolean variadic = false;	660	boolean variadic = false;
660		661
661	List<CsmSpecializationParameter> params2 = new ArrayList<CsmSpecializationParameter>();	662	List<Pair<CsmSpecializationParameter, List<CsmInstantiation>>> params2 = new ArrayList<Pair<CsmSpecializationParameter, List<CsmInstantiation>>>();
662	for (CsmSpecializationParameter param : params) {	663	for (Pair<CsmSpecializationParameter, List<CsmInstantiation>> pair : params) {
		664	CsmSpecializationParameter param = pair.first();
663	if(CsmKindUtilities.isVariadicSpecalizationParameter(param)) {	665	if(CsmKindUtilities.isVariadicSpecalizationParameter(param)) {
664	params2.addAll(((CsmVariadicSpecializationParameter)param).getArgs());	666	for (CsmSpecializationParameter arg : ((CsmVariadicSpecializationParameter)param).getArgs()) {
		667	params2.add(Pair.of(arg, pair.second()));
		668	}
665	variadic = true;	669	variadic = true;
666	} else {	670	} else {
667	params2.add(param);	671	params2.add(pair);
668	}	672	}
669	}	673	}
670	params = params2;	674	params = params2;
Lines 672-678 Link Here
672	if (!specializations.isEmpty()) {	676	if (!specializations.isEmpty()) {
673	int bestMatch = 0;	677	int bestMatch = 0;
674	int paramsSize = 0;	678	int paramsSize = 0;
675	for (CsmSpecializationParameter param : params) {	679	for (Pair<CsmSpecializationParameter, List<CsmInstantiation>> pair : params) {
		680	CsmSpecializationParameter param = pair.first();
676	if(CsmKindUtilities.isVariadicSpecalizationParameter(param)) {	681	if(CsmKindUtilities.isVariadicSpecalizationParameter(param)) {
677	paramsSize += ((CsmVariadicSpecializationParameter)param).getArgs().size();	682	paramsSize += ((CsmVariadicSpecializationParameter)param).getArgs().size();
678	} else {	683	} else {
Lines 682-729 Link Here
682		687
683	List<CharSequence> paramsText = new ArrayList<CharSequence>();	688	List<CharSequence> paramsText = new ArrayList<CharSequence>();
684	List<CsmType> paramsType = new ArrayList<CsmType>();	689	List<CsmType> paramsType = new ArrayList<CsmType>();
685	for (CsmSpecializationParameter param : params) {	690	for (Pair<CsmSpecializationParameter, List<CsmInstantiation>> pair : params) {
		691	CsmSpecializationParameter param = pair.first();
686	if (CsmKindUtilities.isTypeBasedSpecalizationParameter(param)) {	692	if (CsmKindUtilities.isTypeBasedSpecalizationParameter(param)) {
687	CsmType paramType = ((CsmTypeBasedSpecializationParameter) param).getType();	693	CsmType paramType = ((CsmTypeBasedSpecializationParameter) param).getType();
688		694
689	if (CsmKindUtilities.isInstantiation(cls)) {	695	if (CsmKindUtilities.isInstantiation(cls)) {
690	// Try to instantiate type with appropriate instantiations	696	paramType = Instantiation.createType(paramType, pair.second());
691	Iterator<CsmInstantiation> instIters = new Iterator() {	697	// // Try to instantiate type with appropriate instantiations
692		698	// Iterator<CsmInstantiation> instIters = new Iterator() {
693	private CsmInstantiation instantiation = (CsmInstantiation) cls;	699	//
694		700	// private CsmInstantiation instantiation = (CsmInstantiation) cls;
695	@Override	701	//
696	public boolean hasNext() {	702	// @Override
697	return instantiation != null;	703	// public boolean hasNext() {
698	}	704	// return instantiation != null;
699		705	// }
700	@Override	706	//
701	public Object next() {	707	// @Override
702	CsmInstantiation res = instantiation;	708	// public Object next() {
703	if (CsmKindUtilities.isInstantiation(instantiation.getTemplateDeclaration())) {	709	// CsmInstantiation res = instantiation;
704	instantiation = (CsmInstantiation) instantiation.getTemplateDeclaration();	710	// if (CsmKindUtilities.isInstantiation(instantiation.getTemplateDeclaration())) {
705	} else {	711	// instantiation = (CsmInstantiation) instantiation.getTemplateDeclaration();
706	instantiation = null;	712	// } else {
707	}	713	// instantiation = null;
708	return res;	714	// }
709	}	715	// return res;
710		716	// }
711	@Override	717	//
712	public void remove() {	718	// @Override
713	throw new UnsupportedOperationException("Not supported."); // NOI18N	719	// public void remove() {
714	}	720	// throw new UnsupportedOperationException("Not supported."); // NOI18N
715	};	721	// }
716		722	// };
717	CsmType instantiatedType = createTypeInstantiationForTypeParameter((CsmTypeBasedSpecializationParameter) param, instIters, 0);	723	//
718	// CsmType instantiatedType = null;	724	// CsmType instantiatedType = createTypeInstantiationForTypeParameter((CsmTypeBasedSpecializationParameter) param, instIters, 0);
719		725	//// CsmType instantiatedType = null;
720	if (instantiatedType != null) {	726	//
721	// If success then it will be parameter type	727	// if (instantiatedType != null) {
722	paramType = instantiatedType;	728	// // If success then it will be parameter type
723	} else {	729	// paramType = instantiatedType;
724	// If instantiation failed then create instantiation with the the full class isntantiation	730	// } else {
725	paramType = Instantiation.createType(paramType, (CsmInstantiation) cls);	731	// // If instantiation failed then create instantiation with the the full class isntantiation
726	}	732	// paramType = Instantiation.createType(paramType, (CsmInstantiation) cls);
		733	// }
727	}	734	}
728		735
729	paramsType.add(paramType);	736	paramsType.add(paramType);
Lines 746-756 Link Here
746	if (specParams.size() == paramsSize) {	753	if (specParams.size() == paramsSize) {
747	for (int i = 0; i < paramsSize - 1; i++) {	754	for (int i = 0; i < paramsSize - 1; i++) {
748	CsmSpecializationParameter specParam1 = specParams.get(i);	755	CsmSpecializationParameter specParam1 = specParams.get(i);
749	CsmSpecializationParameter param1 = params.get(i);	756	CsmSpecializationParameter param1 = params.get(i).first();
750	// for (int j = i + 1; j < paramsSize; j++) {	757	// for (int j = i + 1; j < paramsSize; j++) {
751	int j = i + 1;	758	int j = i + 1;
752	CsmSpecializationParameter specParam2 = specParams.get(j);	759	CsmSpecializationParameter specParam2 = specParams.get(j);
753	CsmSpecializationParameter param2 = params.get(j);	760	CsmSpecializationParameter param2 = params.get(j).first();
754	if (specParam1.getText().toString().equals(specParam2.getText().toString())	761	if (specParam1.getText().toString().equals(specParam2.getText().toString())
755	&& param1.getText().toString().equals(param2.getText().toString())) {	762	&& param1.getText().toString().equals(param2.getText().toString())) {
756	match += 1;	763	match += 1;
Lines 761-781 Link Here
761	CsmKindUtilities.isTypeBasedSpecalizationParameter(param1) &&	768	CsmKindUtilities.isTypeBasedSpecalizationParameter(param1) &&
762	CsmKindUtilities.isTypeBasedSpecalizationParameter(param2)) {	769	CsmKindUtilities.isTypeBasedSpecalizationParameter(param2)) {
763	CsmTypeBasedSpecializationParameter tbp1 = (CsmTypeBasedSpecializationParameter) param1;	770	CsmTypeBasedSpecializationParameter tbp1 = (CsmTypeBasedSpecializationParameter) param1;
764	CsmType type1 = tbp1.getType();	771	CsmType type1 = paramsType.get(i);
765	if(CsmKindUtilities.isInstantiation(cls)) {	772	// CsmType type1 = tbp1.getType();
766	type1 = Instantiation.createType(tbp1.getType(), (Instantiation)cls);	773	// if(CsmKindUtilities.isInstantiation(cls)) {
767	}	774	// type1 = Instantiation.createType(tbp1.getType(), (Instantiation)cls);
		775	// }
768	CsmClassifier tbsp1Cls = getClassifier(type1);	776	CsmClassifier tbsp1Cls = getClassifier(type1);
769	if (tbsp1Cls != null) {	777	if (tbsp1Cls != null) {
770	CsmTypeBasedSpecializationParameter tbp2 = (CsmTypeBasedSpecializationParameter) param2;	778	CsmTypeBasedSpecializationParameter tbp2 = (CsmTypeBasedSpecializationParameter) param2;
771	CsmType type2 = tbp2.getType();	779	CsmType type2 = paramsType.get(j);
772	if(CsmKindUtilities.isInstantiation(cls)) {	780	// CsmType type2 = tbp2.getType();
773	type2 = Instantiation.createType(tbp2.getType(), (Instantiation)cls);	781	// if(CsmKindUtilities.isInstantiation(cls)) {
774	}	782	// type2 = Instantiation.createType(tbp2.getType(), (Instantiation)cls);
		783	// }
775	CsmClassifier tbsp2Cls = getClassifier(type2);	784	CsmClassifier tbsp2Cls = getClassifier(type2);
776	if(tbsp2Cls != null) {	785	if(tbsp2Cls != null) {
777	if (tbsp1Cls.getQualifiedName().toString().equals(tbsp2Cls.getQualifiedName().toString())) {	786	if (tbsp1Cls.getQualifiedName().toString().equals(tbsp2Cls.getQualifiedName().toString())) {
778	match += 1;	787	match += 1;
		788	} else {
		789	tbsp1Cls = CsmBaseUtilities.getOriginalClassifier(tbsp1Cls, param1.getContainingFile());
		790	tbsp2Cls = CsmBaseUtilities.getOriginalClassifier(tbsp2Cls, param2.getContainingFile());
		791	if (tbsp1Cls.getQualifiedName().toString().equals(tbsp2Cls.getQualifiedName().toString())) {
		792	match += 1;
		793	}
779	}	794	}
780	}	795	}
781	}	796	}
Lines 785-791 Link Here
785	}	800	}
786	for (int i = 0; i < paramsSize; i++) {	801	for (int i = 0; i < paramsSize; i++) {
787	CsmSpecializationParameter specParam = specParams.get(i);	802	CsmSpecializationParameter specParam = specParams.get(i);
788	CsmSpecializationParameter param = params.get(i);	803	CsmSpecializationParameter param = params.get(i).first();
789	if (CsmKindUtilities.isTypeBasedSpecalizationParameter(specParam) &&	804	if (CsmKindUtilities.isTypeBasedSpecalizationParameter(specParam) &&
790	CsmKindUtilities.isTypeBasedSpecalizationParameter(param)) {	805	CsmKindUtilities.isTypeBasedSpecalizationParameter(param)) {
791	CsmTypeBasedSpecializationParameter instSpecParam = (CsmTypeBasedSpecializationParameter)param;	806	CsmTypeBasedSpecializationParameter instSpecParam = (CsmTypeBasedSpecializationParameter)param;
Lines 1017-1028 Link Here
1017	return ExpressionBasedSpecializationParameterImpl.create(expression, file, start, end);	1032	return ExpressionBasedSpecializationParameterImpl.create(expression, file, start, end);
1018	}	1033	}
1019		1034
1020	public List<CsmSpecializationParameter> getInstantiationParams(CsmObject o) {	1035	public List<Pair<CsmSpecializationParameter, List<CsmInstantiation>>> getInstantiationParams(CsmObject o) {
1021	if (!CsmKindUtilities.isInstantiation(o)) {	1036	if (!CsmKindUtilities.isInstantiation(o)) {
1022	return Collections.emptyList();	1037	return Collections.emptyList();
1023	}	1038	}
1024	long time = System.currentTimeMillis();	1039	long time = System.currentTimeMillis();
1025	List<CsmSpecializationParameter> res = new ArrayList<CsmSpecializationParameter>();	1040	List<Pair<CsmSpecializationParameter, List<CsmInstantiation>>> res = new ArrayList<Pair<CsmSpecializationParameter, List<CsmInstantiation>>>();
1026	CsmInstantiation i = (CsmInstantiation) o;	1041	CsmInstantiation i = (CsmInstantiation) o;
1027	Map<CsmTemplateParameter, CsmSpecializationParameter> m = i.getMapping();	1042	Map<CsmTemplateParameter, CsmSpecializationParameter> m = i.getMapping();
1028	CsmOffsetableDeclaration decl = i.getTemplateDeclaration();	1043	CsmOffsetableDeclaration decl = i.getTemplateDeclaration();
Lines 1032-1057 Link Here
1032	for (CsmTemplateParameter tp : ((CsmTemplate)decl).getTemplateParameters()) {	1047	for (CsmTemplateParameter tp : ((CsmTemplate)decl).getTemplateParameters()) {
1033	CsmSpecializationParameter sp = m.get(tp);	1048	CsmSpecializationParameter sp = m.get(tp);
1034	if(sp != null) {	1049	if(sp != null) {
1035	res.add(sp);	1050	List<CsmInstantiation> insts = new ArrayList<>();
		1051	insts.add(i);
		1052	res.add(Pair.of(sp, insts));
1036	}	1053	}
1037	}	1054	}
1038	}	1055	}
1039	} else {	1056	} else {
1040	// non first inst	1057	// non first inst
1041	List<CsmSpecializationParameter> sps = getInstantiationParams(decl);	1058	List<Pair<CsmSpecializationParameter, List<CsmInstantiation>>> sps = getInstantiationParams(decl);
1042	for (CsmSpecializationParameter instParam : sps) {	1059	for (Pair<CsmSpecializationParameter, List<CsmInstantiation>> pair : sps) {
		1060	CsmSpecializationParameter instParam = pair.first();
		1061	List<CsmInstantiation> instantiations = pair.second();
1043	if (CsmKindUtilities.isTypeBasedSpecalizationParameter(instParam) &&	1062	if (CsmKindUtilities.isTypeBasedSpecalizationParameter(instParam) &&
1044	CsmKindUtilities.isTemplateParameterType(((CsmTypeBasedSpecializationParameter) instParam).getType())) {	1063	CsmKindUtilities.isTemplateParameterType(((CsmTypeBasedSpecializationParameter) instParam).getType())) {
1045	CsmTemplateParameterType paramType = (CsmTemplateParameterType) ((CsmTypeBasedSpecializationParameter) instParam).getType();	1064	CsmTemplateParameterType paramType = (CsmTemplateParameterType) ((CsmTypeBasedSpecializationParameter) instParam).getType();
1046	CsmSpecializationParameter newTp = m.get(paramType.getParameter());	1065	CsmSpecializationParameter newTp = m.get(paramType.getParameter());
1047	if (newTp != null && newTp != instParam) {	1066	if (newTp != null && newTp != instParam) {
1048	res.add(newTp);	1067	instantiations.clear();
		1068	res.add(Pair.of(newTp, instantiations));
1049	} else {	1069	} else {
1050	res.add(instParam);	1070	res.add(pair);
1051	}	1071	}
1052	} else {	1072	} else {
1053	res.add(instParam);	1073	res.add(pair);
1054	}	1074	}
		1075	instantiations.add(i);
1055	}	1076	}
1056	}	1077	}
1057	time = System.currentTimeMillis() - time;	1078	time = System.currentTimeMillis() - time;
Lines 1059-1064 Link Here
1059	return res;	1080	return res;
1060	}	1081	}
1061		1082
		1083	private List<CsmSpecializationParameter> getPlainParams(List<Pair<CsmSpecializationParameter, List<CsmInstantiation>>> instParams) {
		1084	List<CsmSpecializationParameter> params = new ArrayList<>(instParams.size());
		1085	for (Pair<CsmSpecializationParameter, List<CsmInstantiation>> pair : instParams) {
		1086	params.add(pair.first());
		1087	}
		1088	return params;
		1089	}
		1090
1062	private CsmClassForwardDeclaration findCsmClassForwardDeclaration(CsmScope scope, CsmClass cls) {	1091	private CsmClassForwardDeclaration findCsmClassForwardDeclaration(CsmScope scope, CsmClass cls) {
1063	if (scope != null) {	1092	if (scope != null) {
1064	if (CsmKindUtilities.isFile(scope)) {	1093	if (CsmKindUtilities.isFile(scope)) {

Lines 83-88 Link Here

(-)a/cnd.modelutil/src/org/netbeans/modules/cnd/modelutil/CsmUtilities.java (-2 / +50 lines)
83	import org.netbeans.modules.cnd.utils.CndPathUtilities;	83	import org.netbeans.modules.cnd.utils.CndPathUtilities;
84	import org.netbeans.modules.cnd.utils.CndUtils;	84	import org.netbeans.modules.cnd.utils.CndUtils;
85	import org.netbeans.modules.cnd.utils.FSPath;	85	import org.netbeans.modules.cnd.utils.FSPath;
		86	import org.netbeans.modules.cnd.utils.MutableObject;
86	import org.netbeans.modules.editor.NbEditorUtilities;	87	import org.netbeans.modules.editor.NbEditorUtilities;
87	import org.openide.awt.StatusDisplayer;	88	import org.openide.awt.StatusDisplayer;
88	import org.openide.cookies.EditorCookie;	89	import org.openide.cookies.EditorCookie;
Lines 1152-1162 Link Here
1152	* @return last type	1153	* @return last type
1153	*/	1154	*/
1154	public static CsmType iterateTypeChain(CsmType type, Predicate<CsmType> stopFilter) {	1155	public static CsmType iterateTypeChain(CsmType type, Predicate<CsmType> stopFilter) {
		1156	return iterateTypeChain(type, stopFilter, 50);
		1157	}
		1158
		1159	/**
		1160	* Iterates type chain until end is reached or stopFilter returned true
		1161	* @param type from iterate should start
		1162	* @param stopFilter
		1163	* @param maxDepth - max number of iterations
		1164	* @return last type
		1165	*/
		1166	public static CsmType iterateTypeChain(CsmType type, Predicate<CsmType> stopFilter, int maxDepth) {
1155	CsmType lastNestedType = type;	1167	CsmType lastNestedType = type;
1156		1168
1157	Set<CsmType> antiLoop = new HashSet<CsmType>();	1169	Set<CsmType> antiLoop = new HashSet<CsmType>();
1158		1170
1159	while (type != null && !antiLoop.contains(type) && antiLoop.size() < 50) {	1171	while (type != null && !antiLoop.contains(type) && antiLoop.size() < maxDepth) {
1160	lastNestedType = type;	1172	lastNestedType = type;
1161		1173
1162	if (stopFilter.check(type)) {	1174	if (stopFilter.check(type)) {
Lines 1175-1181 Link Here
1175	}	1187	}
1176		1188
1177	return lastNestedType;	1189	return lastNestedType;
1178	}	1190	}
		1191
		1192	// public static CsmType checkPointerDepth(CsmType type, int depth, int maxIterations) {
		1193	// final MutableObject<Integer> result = new MutableObject<>(0);
		1194	// iterateTypeChain(type, new Predicate<CsmType>() {
		1195	//
		1196	// @Override
		1197	// public boolean check(CsmType value) {
		1198	// if (value.isPointer()) {
		1199	// result.value += value.getPointerDepth();
		1200	// }
		1201	// return false;
		1202	// }
		1203	//
		1204	// }, maxDepth);
		1205	// return result.value;
		1206	// }
		1207	//
		1208	// public static int checkReference(CsmType type, int maxDepth) {
		1209	// final MutableObject<Integer> result = new MutableObject<>(0);
		1210	// iterateTypeChain(type, new Predicate<CsmType>() {
		1211	//
		1212	// @Override
		1213	// public boolean check(CsmType value) {
		1214	// if (value.isReference()) {
		1215	// if (value.isRValueReference()) {
		1216	// result.value = 2;
		1217	// }
		1218	// result.value = 1;
		1219	// return true;
		1220	// }
		1221	// return false;
		1222	// }
		1223	//
		1224	// }, maxDepth);
		1225	// return result.value;
		1226	// }
1179		1227
1180	//-----------------------------------------------------------------	1228	//-----------------------------------------------------------------
1181		1229