← Back to branch summary

~ubuntu-branches/ubuntu/utopic/kdevelop-php/utopic

« back to all changes in this revision

Viewing changes to duchain/expressionvisitor.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Jonathan Riddell
  • Date: 2010-12-20 14:59:02 UTC
  • mfrom: (1.2.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20101220145902-a6cmovse1qmue52p
Tags: 1.1.80-0ubuntu1
* New upstream release
* Build-dep on kdevplatform >= 1.1.80
* Get rid of l10n packages, not relevant in Ubuntu, put locale files into main package

Show diffs side-by-side

added added

removed removed

Lines of Context:
duchain/expressionvisitor.cpp
40
40
 
41
41
ExpressionVisitor::ExpressionVisitor(EditorIntegrator* editor)
42
42
        : m_editor(editor), m_createProblems(false),
43
 
          m_offset(SimpleCursor::invalid()), m_currentContext(0),
 
43
          m_offset(CursorInRevision::invalid()), m_currentContext(0),
44
44
          m_isAssignmentExpressionEqual(false)
45
45
{
46
46
}
47
47
 
48
 
Declaration* ExpressionVisitor::processVariable(Php::VariableIdentifierAst* variable)
 
48
DeclarationPointer ExpressionVisitor::processVariable(VariableIdentifierAst* variable)
49
49
{
50
50
    Q_ASSERT(m_currentContext);
51
51
 
52
 
    SimpleCursor position = m_editor->findPosition(variable->variable, EditorIntegrator::BackEdge);
 
52
    CursorInRevision position = m_editor->findPosition(variable->variable, EditorIntegrator::BackEdge);
53
53
 
54
54
    if ( m_offset.isValid() ) {
55
55
        position.line += m_offset.line;
56
56
        position.column += m_offset.column;
57
57
    }
58
58
 
59
 
    Declaration* ret = 0;
 
59
    DeclarationPointer ret;
60
60
    Identifier identifier = identifierForNode(variable).last();
61
61
 
62
62
    ifDebug(kDebug() << "processing variable" << identifier.toString() << position.textCursor();)
187
187
    DefaultVisitor::visitVarExpressionNewObject(node);
188
188
    if (node->className->identifier) {
189
189
        const QualifiedIdentifier id = identifierForNamespace(node->className->identifier, m_editor);
190
 
        Declaration* dec = findDeclarationImport(ClassDeclarationType, node->className->identifier,
 
190
        DeclarationPointer dec = findDeclarationImport(ClassDeclarationType, node->className->identifier,
191
191
                                                 id);
192
192
        usingDeclaration(node->className->identifier->namespaceNameSequence->back()->element, dec);
193
193
        buildNamespaceUses(node->className->identifier, id);
194
 
        DUChainReadLocker lock(DUChain::lock());
195
194
        m_result.setDeclaration(dec);
196
195
    }
197
196
}
217
216
            AbstractType::Ptr type;
218
217
            if (it->element->parameterType) {
219
218
                //don't use openTypeFromName as it uses cursor for findDeclarations
220
 
                Declaration* decl = findDeclarationImport(ClassDeclarationType,
 
219
                DeclarationPointer decl = findDeclarationImport(ClassDeclarationType,
221
220
                                                            it->element->parameterType,
222
221
                                                            identifierForNamespace(it->element->parameterType, m_editor));
223
222
                if (decl) {
254
253
        const KDevPG::ListNode< LexicalVarAst* >* it = node->lexicalVars->lexicalVarsSequence->front();
255
254
        DUChainWriteLocker lock;
256
255
        forever {
257
 
            Declaration* found = 0;
 
256
            DeclarationPointer found;
258
257
            foreach(Declaration* dec, m_currentContext->findDeclarations(identifierForNode(it->element->variable))) {
259
258
                if (dec->kind() == Declaration::Instance) {
260
259
                    found = dec;
275
274
 
276
275
void ExpressionVisitor::visitFunctionCallParameterList( FunctionCallParameterListAst* node )
277
276
{
278
 
    QList<Declaration*> decs = m_result.allDeclarations();
 
277
    QList<DeclarationPointer> decs = m_result.allDeclarations();
279
278
    AbstractType::Ptr type = m_result.type();
280
279
 
281
280
    DefaultVisitor::visitFunctionCallParameterList( node );
307
306
                }
308
307
            } else {
309
308
                m_result.setHadUnresolvedIdentifiers(true);
310
 
                usingDeclaration(node->stringFunctionName, 0);
 
309
                usingDeclaration(node->stringFunctionName, DeclarationPointer());
311
310
                m_result.setType(AbstractType::Ptr());
312
311
            }
313
312
        } else if (node->varFunctionName) {
315
314
        } else {
316
315
            //global function call foo();
317
316
            const QualifiedIdentifier id = identifierForNamespace(node->stringFunctionNameOrClass, m_editor);
318
 
            Declaration* dec = findDeclarationImport(FunctionDeclarationType, node->stringFunctionNameOrClass, id);
 
317
            DeclarationPointer dec = findDeclarationImport(FunctionDeclarationType,
 
318
                                                           node->stringFunctionNameOrClass, id);
319
319
            ifDebug(kDebug() << "function call of" << (dec ? dec->toString() : QString("function not found"));)
320
320
            m_result.setDeclaration(dec);
321
321
            usingDeclaration(node->stringFunctionNameOrClass->namespaceNameSequence->back()->element, dec);
333
333
        }
334
334
    }
335
335
}
 
336
///TODO: DUContext pointer?
336
337
DUContext* ExpressionVisitor::findClassContext(IdentifierAst* className)
337
338
{
338
339
    DUContext* context = 0;
339
 
    Declaration* declaration = findDeclarationImport(ClassDeclarationType, className);
 
340
    DeclarationPointer declaration = findDeclarationImport(ClassDeclarationType, className);
340
341
    usingDeclaration(className, declaration);
341
342
    if (declaration) {
342
343
        DUChainReadLocker lock(DUChain::lock());
348
349
    }
349
350
    return context;
350
351
}
351
 
 
 
352
///TODO: DUContext pointer?
352
353
DUContext* ExpressionVisitor::findClassContext(NamespacedIdentifierAst* className)
353
354
{
354
355
    DUContext* context = 0;
357
358
    if (id.count() == 1 && id == staticQId) {
358
359
        return m_currentContext->parentContext();
359
360
    }
360
 
    Declaration* declaration = findDeclarationImport(ClassDeclarationType, className, id);
 
361
    DeclarationPointer declaration = findDeclarationImport(ClassDeclarationType, className, id);
361
362
    usingDeclaration(className->namespaceNameSequence->back()->element, declaration);
362
363
    buildNamespaceUses(className, id);
363
364
    if (declaration) {
385
386
            if (!m_result.allDeclarations().isEmpty()) {
386
387
                usingDeclaration(node->classConstant, m_result.allDeclarations().last());
387
388
            } else {
388
 
                usingDeclaration(node->classConstant, 0);
 
389
                usingDeclaration(node->classConstant, DeclarationPointer());
389
390
            }
390
391
        } else {
391
392
            m_result.setType(AbstractType::Ptr());
399
400
        } else {
400
401
            //constant (created with declare('foo', 'bar')) or const Foo = 1;
401
402
            QualifiedIdentifier id = identifierForNamespace(node->constant, m_editor, true);
402
 
            Declaration* declaration = findDeclarationImport(ConstantDeclarationType, node->constant, id);
 
403
            DeclarationPointer declaration = findDeclarationImport(ConstantDeclarationType, node->constant, id);
403
404
            if (!declaration) {
404
405
                ///TODO: is this really wanted?
405
406
                //it could also be a global function call, without ()
475
476
    DefaultVisitor::visitEncapsVar(node);
476
477
    if (node->variable) {
477
478
        // handle $foo
478
 
        Declaration* dec = processVariable(node->variable);
 
479
        DeclarationPointer dec = processVariable(node->variable);
479
480
        if (dec && node->propertyIdentifier) {
480
481
            // handle property in $foo->bar
481
 
            Declaration* foundDec = 0;
 
482
            DeclarationPointer foundDec;
482
483
            DUChainReadLocker lock(DUChain::lock());
483
484
            if ( StructureType::Ptr structType = dec->type<StructureType>() ) {
484
485
                if ( ClassDeclaration* cdec = dynamic_cast<ClassDeclaration*>(structType->declaration(m_currentContext->topContext())) ) {
538
539
                            }
539
540
                        }
540
541
                    }
 
542
                    m_result.setDeclarations(decs);
541
543
                    lock.unlock();
542
 
                    m_result.setDeclarations(decs);
543
544
                    if (!m_result.allDeclarations().isEmpty()) {
544
545
                        if ( !m_isAssignmentExpressionEqual ) {
545
546
                            usingDeclaration(node->objectProperty->objectDimList->variableName, m_result.allDeclarations().last());
554
555
                        }
555
556
                    } else {
556
557
                        if ( !m_isAssignmentExpressionEqual ) {
557
 
                            usingDeclaration(node->objectProperty->objectDimList->variableName, 0);
 
558
                            usingDeclaration(node->objectProperty->objectDimList->variableName,
 
559
                                             DeclarationPointer());
558
560
                        }
559
561
                        m_result.setType(AbstractType::Ptr());
560
562
                    }
582
584
            if (!m_result.allDeclarations().isEmpty()) {
583
585
                usingDeclaration(node->variable->variable->variable, m_result.allDeclarations().last());
584
586
            } else {
585
 
                usingDeclaration(node->variable->variable->variable, 0);
 
587
                usingDeclaration(node->variable->variable->variable, DeclarationPointer());
586
588
            }
587
589
        } else {
588
 
            usingDeclaration(node->className, 0);
 
590
            usingDeclaration(node->className, DeclarationPointer());
589
591
            m_result.setType(AbstractType::Ptr());
590
592
        }
591
593
        if (node->variable->offsetItemsSequence) {
617
619
            break;
618
620
        case CastObject: {
619
621
            /// Qualified identifier for 'stdclass'
620
 
            static const KDevelop::QualifiedIdentifier stdclassQId("stdclass");
 
622
            static const QualifiedIdentifier stdclassQId("stdclass");
621
623
            DUChainReadLocker lock(DUChain::lock());
622
624
            m_result.setDeclarations(m_currentContext->findDeclarations(stdclassQId));
623
625
            break;
683
685
    m_createProblems = v;
684
686
}
685
687
 
686
 
void ExpressionVisitor::setOffset(SimpleCursor offset)
 
688
void ExpressionVisitor::setOffset(const CursorInRevision& offset)
687
689
{
688
690
    m_offset = offset;
689
691
}
696
698
    for ( int i = 0; i < identifier.count() - 1; ++i ) {
697
699
        curId.push(identifier.at(i));
698
700
        AstNode* node = namespaces->namespaceNameSequence->at(i)->element;
699
 
        Declaration* dec = findDeclarationImport(NamespaceDeclarationType, node, curId);
 
701
        DeclarationPointer dec = findDeclarationImport(NamespaceDeclarationType, node, curId);
700
702
        usingDeclaration(node, dec);
701
703
    }
702
704
}
703
705
 
704
 
Declaration* ExpressionVisitor::findDeclarationImport(DeclarationType declarationType, IdentifierAst* node)
 
706
DeclarationPointer ExpressionVisitor::findDeclarationImport(DeclarationType declarationType, IdentifierAst* node)
705
707
{
706
708
    // methods and class names are case insensitive
707
709
    QualifiedIdentifier id;
713
715
    return findDeclarationImport(declarationType, node, id);
714
716
}
715
717
 
716
 
Declaration* ExpressionVisitor::findDeclarationImport(DeclarationType declarationType, VariableIdentifierAst* node)
 
718
DeclarationPointer ExpressionVisitor::findDeclarationImport(DeclarationType declarationType, VariableIdentifierAst* node)
717
719
{
718
720
    return findDeclarationImport(declarationType, node, identifierForNode(node));
719
721
}
720
722
 
721
 
Declaration* ExpressionVisitor::findDeclarationImport(DeclarationType declarationType, AstNode* node, const KDevelop::QualifiedIdentifier& identifier)
 
723
DeclarationPointer ExpressionVisitor::findDeclarationImport( DeclarationType declarationType, AstNode* node, const QualifiedIdentifier& identifier)
722
724
{
723
725
    return findDeclarationImportHelper(m_currentContext, identifier, declarationType, node, m_editor);
724
726
}