d/dmd/cond.c

/* Compiler implementation of the D programming language
 * Copyright (C) 1999-2021 by The D Language Foundation, All Rights Reserved
 * written by Walter Bright
 * http://www.digitalmars.com
 * Distributed under the Boost Software License, Version 1.0.
 * http://www.boost.org/LICENSE_1_0.txt
 * https://github.com/D-Programming-Language/dmd/blob/master/src/cond.c
 */

#include "root/dsystem.h"               // strcmp()

#include "mars.h"
#include "id.h"
#include "init.h"
#include "aggregate.h"
#include "declaration.h"
#include "identifier.h"
#include "expression.h"
#include "cond.h"
#include "module.h"
#include "template.h"
#include "mtype.h"
#include "scope.h"
#include "statement.h"
#include "arraytypes.h"
#include "tokens.h"

bool evalStaticCondition(Scope *sc, Expression *exp, Expression *e, bool &errors);

int findCondition(Identifiers *ids, Identifier *ident)
{
    if (ids)
    {
        for (size_t i = 0; i < ids->length; i++)
        {
            Identifier *id = (*ids)[i];

            if (id == ident)
                return true;
        }
    }

    return false;
}

/* ============================================================ */

Condition::Condition(Loc loc)
{
    this->loc = loc;
    inc = 0;
}

/* ============================================================ */

StaticForeach::StaticForeach(Loc loc, ForeachStatement *aggrfe, ForeachRangeStatement *rangefe)
{
    assert(!!aggrfe ^ !!rangefe);
    this->loc = loc;
    this->aggrfe = aggrfe;
    this->rangefe = rangefe;
    this->needExpansion = false;
}

StaticForeach *StaticForeach::syntaxCopy()
{
    return new StaticForeach(
        loc,
        aggrfe ? (ForeachStatement *)aggrfe->syntaxCopy() : NULL,
        rangefe ? (ForeachRangeStatement *)rangefe->syntaxCopy() : NULL
    );
}

/*****************************************
 * Turn an aggregate which is an array into an expression tuple
 * of its elements. I.e., lower
 *     static foreach (x; [1, 2, 3, 4]) { ... }
 * to
 *     static foreach (x; AliasSeq!(1, 2, 3, 4)) { ... }
 */

static void lowerArrayAggregate(StaticForeach *sfe, Scope *sc)
{
    Expression *aggr = sfe->aggrfe->aggr;
    Expression *el = new ArrayLengthExp(aggr->loc, aggr);
    sc = sc->startCTFE();
    el = expressionSemantic(el, sc);
    sc = sc->endCTFE();
    el = el->optimize(WANTvalue);
    el = el->ctfeInterpret();
    if (el->op == TOKint64)
    {
        Expressions *es;
        if (ArrayLiteralExp *ale = aggr->isArrayLiteralExp())
        {
            // Directly use the elements of the array for the TupleExp creation
            es = ale->elements;
        }
        else
        {
            size_t length = (size_t)el->toInteger();
            es = new Expressions();
            es->setDim(length);
            for (size_t i = 0; i < length; i++)
            {
                IntegerExp *index = new IntegerExp(sfe->loc, i, Type::tsize_t);
                Expression *value = new IndexExp(aggr->loc, aggr, index);
                (*es)[i] = value;
            }
        }
        sfe->aggrfe->aggr = new TupleExp(aggr->loc, es);
        sfe->aggrfe->aggr = expressionSemantic(sfe->aggrfe->aggr, sc);
        sfe->aggrfe->aggr = sfe->aggrfe->aggr->optimize(WANTvalue);
        sfe->aggrfe->aggr = sfe->aggrfe->aggr->ctfeInterpret();
    }
    else
    {
        sfe->aggrfe->aggr = new ErrorExp();
    }
}

/*****************************************
 * Wrap a statement into a function literal and call it.
 *
 * Params:
 *     loc = The source location.
 *     s  = The statement.
 * Returns:
 *     AST of the expression `(){ s; }()` with location loc.
 */

static Expression *wrapAndCall(Loc loc, Statement *s)
{
    TypeFunction *tf = new TypeFunction(ParameterList(), NULL, LINKdefault, 0);
    FuncLiteralDeclaration *fd = new FuncLiteralDeclaration(loc, loc, tf, TOKreserved, NULL);
    fd->fbody = s;
    FuncExp *fe = new FuncExp(loc, fd);
    Expression *ce = new CallExp(loc, fe, new Expressions());
    return ce;
}

/*****************************************
 * Create a `foreach` statement from `aggrefe/rangefe` with given
 * `foreach` variables and body `s`.
 *
 * Params:
 *     loc = The source location.
 *     parameters = The foreach variables.
 *     s = The `foreach` body.
 * Returns:
 *     `foreach (parameters; aggregate) s;` or
 *     `foreach (parameters; lower .. upper) s;`
 *     Where aggregate/lower, upper are as for the current StaticForeach.
 */

static Statement *createForeach(StaticForeach *sfe, Loc loc, Parameters *parameters, Statement *s)
{
    if (sfe->aggrfe)
    {
        return new ForeachStatement(loc, sfe->aggrfe->op, parameters, sfe->aggrfe->aggr->syntaxCopy(), s, loc);
    }
    else
    {
        assert(sfe->rangefe && parameters->length == 1);
        return new ForeachRangeStatement(loc, sfe->rangefe->op, (*parameters)[0],
                                         sfe->rangefe->lwr->syntaxCopy(),
                                         sfe->rangefe->upr->syntaxCopy(), s, loc);
    }
}

/*****************************************
 * For a `static foreach` with multiple loop variables, the
 * aggregate is lowered to an array of tuples. As D does not have
 * built-in tuples, we need a suitable tuple type. This generates
 * a `struct` that serves as the tuple type. This type is only
 * used during CTFE and hence its typeinfo will not go to the
 * object file.
 *
 * Params:
 *     loc = The source location.
 *     e = The expressions we wish to store in the tuple.
 *     sc  = The current scope.
 * Returns:
 *     A struct type of the form
 *         struct Tuple
 *         {
 *             typeof(AliasSeq!(e)) tuple;
 *         }
 */

static TypeStruct *createTupleType(Loc loc, Expressions *e)
{   // TODO: move to druntime?
    Identifier *sid = Identifier::generateId("Tuple");
    StructDeclaration *sdecl = new StructDeclaration(loc, sid, false);
    sdecl->storage_class |= STCstatic;
    sdecl->members = new Dsymbols();
    Identifier *fid = Identifier::idPool("tuple");
    Type *ty = new TypeTypeof(loc, new TupleExp(loc, e));
    sdecl->members->push(new VarDeclaration(loc, ty, fid, NULL));
    TypeStruct *r = (TypeStruct *)sdecl->type;
    if (global.params.useTypeInfo && Type::dtypeinfo)
        r->vtinfo = TypeInfoStructDeclaration::create(r); // prevent typeinfo from going to object file
    return r;
}

/*****************************************
 * Create the AST for an instantiation of a suitable tuple type.
 *
 * Params:
 *     loc = The source location.
 *     type = A Tuple type, created with createTupleType.
 *     e = The expressions we wish to store in the tuple.
 * Returns:
 *     An AST for the expression `Tuple(e)`.
 */

static Expression *createTuple(Loc loc, TypeStruct *type, Expressions *e)
{   // TODO: move to druntime?
    return new CallExp(loc, new TypeExp(loc, type), e);
}

/*****************************************
 * Lower any aggregate that is not an array to an array using a
 * regular foreach loop within CTFE.  If there are multiple
 * `static foreach` loop variables, an array of tuples is
 * generated. In thise case, the field `needExpansion` is set to
 * true to indicate that the static foreach loop expansion will
 * need to expand the tuples into multiple variables.
 *
 * For example, `static foreach (x; range) { ... }` is lowered to:
 *
 *     static foreach (x; {
 *         typeof({
 *             foreach (x; range) return x;
 *         }())[] __res;
 *         foreach (x; range) __res ~= x;
 *         return __res;
 *     }()) { ... }
 *
 * Finally, call `lowerArrayAggregate` to turn the produced
 * array into an expression tuple.
 *
 * Params:
 *     sc = The current scope.
 */

static void lowerNonArrayAggregate(StaticForeach *sfe, Scope *sc)
{
    size_t nvars = sfe->aggrfe ? sfe->aggrfe->parameters->length : 1;
    Loc aloc = sfe->aggrfe ? sfe->aggrfe->aggr->loc : sfe->rangefe->lwr->loc;
    // We need three sets of foreach loop variables because the
    // lowering contains three foreach loops.
    Parameters *pparams[3] = {new Parameters(), new Parameters(), new Parameters()};
    for (size_t i = 0; i < nvars; i++)
    {
        for (size_t j = 0; j < 3; j++)
        {
            Parameters *params = pparams[j];
            Parameter *p = sfe->aggrfe ? (*sfe->aggrfe->parameters)[i] : sfe->rangefe->prm;
            params->push(new Parameter(p->storageClass, p->type, p->ident, NULL, NULL));
        }
    }
    Expression *res[2];
    TypeStruct *tplty = NULL;
    if (nvars == 1) // only one `static foreach` variable, generate identifiers.
    {
        for (size_t i = 0; i < 2; i++)
        {
            res[i] = new IdentifierExp(aloc, (*pparams[i])[0]->ident);
        }
    }
    else // multiple `static foreach` variables, generate tuples.
    {
        for (size_t i = 0; i < 2; i++)
        {
            Expressions *e = new Expressions();
            for (size_t j = 0; j < pparams[0]->length; j++)
            {
                Parameter *p = (*pparams[i])[j];
                e->push(new IdentifierExp(aloc, p->ident));
            }
            if (!tplty)
            {
                tplty = createTupleType(aloc, e);
            }
            res[i] = createTuple(aloc, tplty, e);
        }
        sfe->needExpansion = true; // need to expand the tuples later
    }
    // generate remaining code for the new aggregate which is an
    // array (see documentation comment).
    if (sfe->rangefe)
    {
        sc = sc->startCTFE();
        sfe->rangefe->lwr = expressionSemantic(sfe->rangefe->lwr, sc);
        sfe->rangefe->lwr = resolveProperties(sc, sfe->rangefe->lwr);
        sfe->rangefe->upr = expressionSemantic(sfe->rangefe->upr, sc);
        sfe->rangefe->upr = resolveProperties(sc, sfe->rangefe->upr);
        sc = sc->endCTFE();
        sfe->rangefe->lwr = sfe->rangefe->lwr->optimize(WANTvalue);
        sfe->rangefe->lwr = sfe->rangefe->lwr->ctfeInterpret();
        sfe->rangefe->upr = sfe->rangefe->upr->optimize(WANTvalue);
        sfe->rangefe->upr = sfe->rangefe->upr->ctfeInterpret();
    }
    Statements *s1 = new Statements();
    Statements *sfebody = new Statements();
    if (tplty) sfebody->push(new ExpStatement(sfe->loc, tplty->sym));
    sfebody->push(new ReturnStatement(aloc, res[0]));
    s1->push(createForeach(sfe, aloc, pparams[0], new CompoundStatement(aloc, sfebody)));
    s1->push(new ExpStatement(aloc, new AssertExp(aloc, new IntegerExp(aloc, 0, Type::tint32))));
    Type *ety = new TypeTypeof(aloc, wrapAndCall(aloc, new CompoundStatement(aloc, s1)));
    Type *aty = ety->arrayOf();
    Identifier *idres = Identifier::generateId("__res");
    VarDeclaration *vard = new VarDeclaration(aloc, aty, idres, NULL);
    Statements *s2 = new Statements();

    // Run 'typeof' gagged to avoid duplicate errors and if it fails just create
    // an empty foreach to expose them.
    unsigned olderrors = global.startGagging();
    ety = typeSemantic(ety, aloc, sc);
    if (global.endGagging(olderrors))
        s2->push(createForeach(sfe, aloc, pparams[1], NULL));
    else
    {
        s2->push(new ExpStatement(aloc, vard));
        Expression *catass = new CatAssignExp(aloc, new IdentifierExp(aloc, idres), res[1]);
        s2->push(createForeach(sfe, aloc, pparams[1], new ExpStatement(aloc, catass)));
        s2->push(new ReturnStatement(aloc, new IdentifierExp(aloc, idres)));
    }

    Expression *aggr;
    Type *indexty;

    if (sfe->rangefe && (indexty = ety)->isintegral())
    {
        sfe->rangefe->lwr->type = indexty;
        sfe->rangefe->upr->type = indexty;
        IntRange lwrRange = getIntRange(sfe->rangefe->lwr);
        IntRange uprRange = getIntRange(sfe->rangefe->upr);

        const dinteger_t lwr = sfe->rangefe->lwr->toInteger();
        dinteger_t upr = sfe->rangefe->upr->toInteger();
        size_t length = 0;

        if (lwrRange.imin <= uprRange.imax)
            length = (size_t)(upr - lwr);

        Expressions *exps = new Expressions();
        exps->setDim(length);

        if (sfe->rangefe->op == TOKforeach)
        {
            for (size_t i = 0; i < length; i++)
                (*exps)[i] = new IntegerExp(aloc, lwr + i, indexty);
        }
        else
        {
            --upr;
            for (size_t i = 0; i < length; i++)
                (*exps)[i] = new IntegerExp(aloc, upr - i, indexty);
        }
        aggr = new ArrayLiteralExp(aloc, indexty->arrayOf(), exps);
    }
    else
    {
        aggr = wrapAndCall(aloc, new CompoundStatement(aloc, s2));
        sc = sc->startCTFE();
        aggr = expressionSemantic(aggr, sc);
        aggr = resolveProperties(sc, aggr);
        sc = sc->endCTFE();
        aggr = aggr->optimize(WANTvalue);
        aggr = aggr->ctfeInterpret();
    }

    assert(!!sfe->aggrfe ^ !!sfe->rangefe);
    sfe->aggrfe = new ForeachStatement(sfe->loc, TOKforeach, pparams[2], aggr,
                                  sfe->aggrfe ? sfe->aggrfe->_body : sfe->rangefe->_body,
                                  sfe->aggrfe ? sfe->aggrfe->endloc : sfe->rangefe->endloc);
    sfe->rangefe = NULL;
    lowerArrayAggregate(sfe, sc); // finally, turn generated array into expression tuple
}

/*****************************************
 * Perform `static foreach` lowerings that are necessary in order
 * to finally expand the `static foreach` using
 * `ddmd.statementsem.makeTupleForeach`.
 */

void staticForeachPrepare(StaticForeach *sfe, Scope *sc)
{
    assert(sc);
    if (sfe->aggrfe)
    {
        sc = sc->startCTFE();
        sfe->aggrfe->aggr = expressionSemantic(sfe->aggrfe->aggr, sc);
        sc = sc->endCTFE();
        sfe->aggrfe->aggr = sfe->aggrfe->aggr->optimize(WANTvalue);
    }

    if (sfe->aggrfe && sfe->aggrfe->aggr->type->toBasetype()->ty == Terror)
    {
        return;
    }

    if (!staticForeachReady(sfe))
    {
        if (sfe->aggrfe && sfe->aggrfe->aggr->type->toBasetype()->ty == Tarray)
        {
            lowerArrayAggregate(sfe, sc);
        }
        else
        {
            lowerNonArrayAggregate(sfe, sc);
        }
    }
}

/*****************************************
 * Returns:
 *     `true` iff ready to call `ddmd.statementsem.makeTupleForeach`.
 */

bool staticForeachReady(StaticForeach *sfe)
{
    return sfe->aggrfe && sfe->aggrfe->aggr && sfe->aggrfe->aggr->type &&
        sfe->aggrfe->aggr->type->toBasetype()->ty == Ttuple;
}

/* ============================================================ */

DVCondition::DVCondition(Module *mod, unsigned level, Identifier *ident)
        : Condition(Loc())
{
    this->mod = mod;
    this->level = level;
    this->ident = ident;
}

Condition *DVCondition::syntaxCopy()
{
    return this;        // don't need to copy
}

/* ============================================================ */

void DebugCondition::addGlobalIdent(const char *ident)
{
    if (!global.debugids)
        global.debugids = new Identifiers();
    global.debugids->push(Identifier::idPool(ident));
}


DebugCondition::DebugCondition(Module *mod, unsigned level, Identifier *ident)
    : DVCondition(mod, level, ident)
{
}

// Helper for printing dependency information
void printDepsConditional(Scope *sc, DVCondition* condition, const char* depType)
{
    if (!global.params.moduleDeps || global.params.moduleDepsFile.length)
        return;
    OutBuffer *ob = global.params.moduleDeps;
    Module* imod = sc ? sc->instantiatingModule() : condition->mod;
    if (!imod)
        return;
    ob->writestring(depType);
    ob->writestring(imod->toPrettyChars());
    ob->writestring(" (");
    escapePath(ob, imod->srcfile->toChars());
    ob->writestring(") : ");
    if (condition->ident)
        ob->printf("%s\n", condition->ident->toChars());
    else
        ob->printf("%d\n", condition->level);
}


int DebugCondition::include(Scope *sc)
{
    //printf("DebugCondition::include() level = %d, debuglevel = %d\n", level, global.params.debuglevel);
    if (inc == 0)
    {
        inc = 2;
        bool definedInModule = false;
        if (ident)
        {
            if (findCondition(mod->debugids, ident))
            {
                inc = 1;
                definedInModule = true;
            }
            else if (findCondition(global.debugids, ident))
                inc = 1;
            else
            {   if (!mod->debugidsNot)
                    mod->debugidsNot = new Identifiers();
                mod->debugidsNot->push(ident);
            }
        }
        else if (level <= global.params.debuglevel || level <= mod->debuglevel)
            inc = 1;
        if (!definedInModule)
            printDepsConditional(sc, this, "depsDebug ");
    }
    return (inc == 1);
}

/* ============================================================ */

static bool isReserved(const char *ident)
{
    static const char* reserved[] =
    {
        "DigitalMars",
        "GNU",
        "LDC",
        "SDC",
        "Windows",
        "Win32",
        "Win64",
        "linux",
        "OSX",
        "FreeBSD",
        "OpenBSD",
        "NetBSD",
        "DragonFlyBSD",
        "BSD",
        "Solaris",
        "Posix",
        "AIX",
        "Haiku",
        "SkyOS",
        "SysV3",
        "SysV4",
        "Hurd",
        "Android",
        "PlayStation",
        "PlayStation4",
        "Cygwin",
        "MinGW",
        "FreeStanding",
        "X86",
        "X86_64",
        "ARM",
        "ARM_Thumb",
        "ARM_SoftFloat",
        "ARM_SoftFP",
        "ARM_HardFloat",
        "AArch64",
        "Epiphany",
        "PPC",
        "PPC_SoftFloat",
        "PPC_HardFloat",
        "PPC64",
        "IA64",
        "MIPS32",
        "MIPS64",
        "MIPS_O32",
        "MIPS_N32",
        "MIPS_O64",
        "MIPS_N64",
        "MIPS_EABI",
        "MIPS_SoftFloat",
        "MIPS_HardFloat",
        "MSP430",
        "NVPTX",
        "NVPTX64",
        "RISCV32",
        "RISCV64",
        "SPARC",
        "SPARC_V8Plus",
        "SPARC_SoftFloat",
        "SPARC_HardFloat",
        "SPARC64",
        "S390",
        "S390X",
        "HPPA",
        "HPPA64",
        "SH",
        "Alpha",
        "Alpha_SoftFloat",
        "Alpha_HardFloat",
        "LittleEndian",
        "BigEndian",
        "ELFv1",
        "ELFv2",
        "CRuntime_Digitalmars",
        "CRuntime_Glibc",
        "CRuntime_Microsoft",
        "CRuntime_Musl",
        "CRuntime_UClibc",
        "CppRuntime_Clang",
        "CppRuntime_DigitalMars",
        "CppRuntime_Gcc",
        "CppRuntime_Microsoft",
        "CppRuntime_Sun",
        "D_Coverage",
        "D_Ddoc",
        "D_InlineAsm_X86",
        "D_InlineAsm_X86_64",
        "D_LP64",
        "D_X32",
        "D_HardFloat",
        "D_SoftFloat",
        "D_PIC",
        "D_SIMD",
        "D_Version2",
        "D_NoBoundsChecks",
        "unittest",
        "assert",
        "all",
        "none",
        NULL
    };

    for (unsigned i = 0; reserved[i]; i++)
    {
        if (strcmp(ident, reserved[i]) == 0)
            return true;
    }

    if (ident[0] == 'D' && ident[1] == '_')
        return true;
    return false;
}

void checkReserved(Loc loc, const char *ident)
{
    if (isReserved(ident))
        error(loc, "version identifier `%s` is reserved and cannot be set", ident);
}

void VersionCondition::addGlobalIdent(const char *ident)
{
    checkReserved(Loc(), ident);
    addPredefinedGlobalIdent(ident);
}

void VersionCondition::addPredefinedGlobalIdent(const char *ident)
{
    if (!global.versionids)
        global.versionids = new Identifiers();
    global.versionids->push(Identifier::idPool(ident));
}


VersionCondition::VersionCondition(Module *mod, unsigned level, Identifier *ident)
    : DVCondition(mod, level, ident)
{
}

int VersionCondition::include(Scope *sc)
{
    //printf("VersionCondition::include() level = %d, versionlevel = %d\n", level, global.params.versionlevel);
    //if (ident) printf("\tident = '%s'\n", ident->toChars());
    if (inc == 0)
    {
        inc = 2;
        bool definedInModule=false;
        if (ident)
        {
            if (findCondition(mod->versionids, ident))
            {
                inc = 1;
                definedInModule = true;
            }
            else if (findCondition(global.versionids, ident))
                inc = 1;
            else
            {
                if (!mod->versionidsNot)
                    mod->versionidsNot = new Identifiers();
                mod->versionidsNot->push(ident);
            }
        }
        else if (level <= global.params.versionlevel || level <= mod->versionlevel)
            inc = 1;
        if (!definedInModule && (!ident || (!isReserved(ident->toChars()) && ident != Id::_unittest && ident != Id::_assert)))
            printDepsConditional(sc, this, "depsVersion ");
    }
    return (inc == 1);
}

/**************************** StaticIfCondition *******************************/

StaticIfCondition::StaticIfCondition(Loc loc, Expression *exp)
    : Condition(loc)
{
    this->exp = exp;
}

Condition *StaticIfCondition::syntaxCopy()
{
    return new StaticIfCondition(loc, exp->syntaxCopy());
}

int StaticIfCondition::include(Scope *sc)
{
    if (inc == 0)
    {
        if (!sc)
        {
            error(loc, "static if conditional cannot be at global scope");
            inc = 2;
            return 0;
        }

        sc = sc->push(sc->scopesym);

        bool errors = false;

        if (!exp)
            goto Lerror;

        bool result = evalStaticCondition(sc, exp, exp, errors);
        sc->pop();

        // Prevent repeated condition evaluation.
        // See: fail_compilation/fail7815.d
        if (inc != 0)
            return (inc == 1);
        if (errors)
            goto Lerror;
        if (result)
            inc = 1;
        else
            inc = 2;
    }
    return (inc == 1);

Lerror:
    if (!global.gag)
        inc = 2;                // so we don't see the error message again
    return 0;
}