Пример #1
0
void CompileableMethodsInAContainer::Init
(
    BCSYM_Container *pContainer,
    bool fLookOnlyInCurrentPartialType
)
{
    // Free the memory.
    m_nra.FreeHeap();

    if (pContainer != NULL)
    {
        // Look in only this container and ignore its other partial containers
        //
        BCITER_CHILD_ALL bichild(pContainer, fLookOnlyInCurrentPartialType);

        unsigned cMethods = 0;
        BCSYM_NamedRoot *pRoot;
        BCSYM_Proc **ppProc;

        while (pRoot = bichild.GetNext())
        {
            if (pRoot->IsMethodImpl() ||
                    pRoot->IsSyntheticMethod() ||
                    pRoot->IsProperty() ||
                    pRoot->IsEventDecl())
            {
                cMethods++;
            }
        }

        IfFalseThrow(cMethods + 1 > cMethods);
        ppProc = m_ppNext = (BCSYM_Proc **)m_nra.Alloc(VBMath::Multiply(
            (cMethods + 1), 
            sizeof(BCSYM_Proc *)));

        bichild.Reset();

        while (pRoot = bichild.GetNext())
        {
            if (pRoot->IsMethodImpl() ||
                    pRoot->IsSyntheticMethod() ||
                    pRoot->IsProperty() ||
                    pRoot->IsEventDecl())
            {
                *ppProc = pRoot->PProc();
                ppProc++;
            }
        }

        // Sort the list in file definition order.
        extern int _cdecl SortSymbolsByLocation(const void *arg1, const void *arg2);

        qsort(m_ppNext, ppProc - m_ppNext, sizeof(BCSYM_Proc *), SortSymbolsByLocation);
    }
    else
    {
        m_ppNext = NULL;
    }
}
void CLSComplianceChecker::VerifyOverloadsForCLSCompliance(BCSYM_Proc * PossiblyOverloadedProc)
{
    // Check the Overloads for overloading by Array Rank or
    // overloading on Array of Arrays

    // we don't allow bad members because they could have
    // been bad during overloads verification in bindable.
    //
    VSASSERT( !PossiblyOverloadedProc->IsBad(),
                    "Bad members unexpected!!!");

    if (!Bindable::IsMethod(PossiblyOverloadedProc) &&
        !Bindable::IsProperty(PossiblyOverloadedProc))
    {
        return;
    }

    for(BCSYM_NamedRoot *NextPossibleOverload = PossiblyOverloadedProc->GetNextOverload();
        NextPossibleOverload;
        NextPossibleOverload = NextPossibleOverload->GetNextOverload())
    {
        VSASSERT( NextPossibleOverload->IsProc(),
                    "How can a non-proc be involved in overloads ?");

        BCSYM_Proc *NextOverload = NextPossibleOverload->PProc();

        if (!IsAccessibleOutsideAssembly(NextOverload))
        {
            continue;
        }

        VerifyOverloadsForCLSCompliance(
            PossiblyOverloadedProc,
            NextOverload);
    }

    // 














}
Пример #3
0
DLRExpressionTree*
ETSemanticsForLambdas::ConvertLambda
(
    ILTree::Expression* Input,
    ExpressionFlags Flags,
    Type* TargetType
)
{
    ThrowIfNull(Input);
    ThrowIfFalse(Input->bilop == SX_LAMBDA);

    // Don't allow Sub lambdas to be converted to expression trees.
    if (Input->ResultType->IsDelegate())
    {
        BCSYM_NamedRoot* proc = GetInvokeFromDelegate(Input->ResultType, m_Compiler);
        if(proc && proc->PProc() && (!proc->PProc()->GetType() || TypeHelpers::IsVoidType(proc->PProc()->GetType())))
        {
            ReportErrorForExpressionTree( ERRID_StatementLambdaInExpressionTree, Input->Loc );
            return NULL;
        }
    }

    return ExpressionTreeSemantics<DLRExpressionTree>::ConvertLambda(Input, Flags, TargetType);
}