| |
| /* 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/traits.c |
| */ |
| |
| #include "root/dsystem.h" |
| #include "root/rmem.h" |
| #include "root/aav.h" |
| #include "root/checkedint.h" |
| |
| #include "errors.h" |
| #include "mtype.h" |
| #include "init.h" |
| #include "expression.h" |
| #include "template.h" |
| #include "utf.h" |
| #include "enum.h" |
| #include "scope.h" |
| #include "hdrgen.h" |
| #include "statement.h" |
| #include "declaration.h" |
| #include "aggregate.h" |
| #include "import.h" |
| #include "id.h" |
| #include "dsymbol.h" |
| #include "module.h" |
| #include "attrib.h" |
| #include "parse.h" |
| #include "root/speller.h" |
| #include "target.h" |
| |
| typedef int (*ForeachDg)(void *ctx, size_t idx, Dsymbol *s); |
| int ScopeDsymbol_foreach(Scope *sc, Dsymbols *members, ForeachDg dg, void *ctx, size_t *pn = NULL); |
| void freeFieldinit(Scope *sc); |
| Expression *resolve(Loc loc, Scope *sc, Dsymbol *s, bool hasOverloads); |
| Package *resolveIsPackage(Dsymbol *sym); |
| Expression *typeToExpression(Type *t); |
| Type *decoToType(const char *deco); |
| bool expressionsToString(OutBuffer &buf, Scope *sc, Expressions *exps); |
| |
| |
| /************************************************ |
| * Delegate to be passed to overloadApply() that looks |
| * for functions matching a trait. |
| */ |
| |
| struct Ptrait |
| { |
| Dsymbol *sym; |
| Expression *e1; |
| Expressions *exps; // collected results |
| Identifier *ident; // which trait we're looking for |
| bool includeTemplates; |
| AA **funcTypeHash; |
| }; |
| |
| /* Compute the function signature and insert it in the |
| * hashtable, if not present. This is needed so that |
| * traits(getOverlods, F3, "visit") does not count `int visit(int)` |
| * twice in the following example: |
| * |
| * ============================================= |
| * interface F1 { int visit(int);} |
| * interface F2 { int visit(int); void visit(); } |
| * interface F3 : F2, F1 {} |
| *============================================== |
| */ |
| static void insertInterfaceInheritedFunction(Ptrait *p, FuncDeclaration *fd, Expression *e) |
| { |
| Identifier *signature = Identifier::idPool(fd->type->toChars()); |
| //printf("%s - %s\n", fd->toChars, signature); |
| if (!dmd_aaGetRvalue(*p->funcTypeHash, (void *)signature)) |
| { |
| bool* value = (bool*) dmd_aaGet(p->funcTypeHash, (void *)signature); |
| *value = true; |
| p->exps->push(e); |
| } |
| } |
| |
| static int fptraits(void *param, Dsymbol *s) |
| { |
| Ptrait *p = (Ptrait *)param; |
| if (p->includeTemplates) |
| { |
| p->exps->push(new DsymbolExp(Loc(),s, false)); |
| return 0; |
| } |
| FuncDeclaration *fd = s->isFuncDeclaration(); |
| if (!fd) |
| return 0; |
| |
| if (p->ident == Id::getVirtualFunctions && !fd->isVirtual()) |
| return 0; |
| |
| if (p->ident == Id::getVirtualMethods && !fd->isVirtualMethod()) |
| return 0; |
| |
| Expression *e; |
| FuncAliasDeclaration* ad = new FuncAliasDeclaration(fd->ident, fd, false); |
| ad->protection = fd->protection; |
| if (p->e1) |
| e = new DotVarExp(Loc(), p->e1, ad, false); |
| else |
| e = new DsymbolExp(Loc(), ad, false); |
| // if the parent is an interface declaration |
| // we must check for functions with the same signature |
| // in different inherited interfaces |
| if (p->sym && p->sym->isInterfaceDeclaration()) |
| insertInterfaceInheritedFunction(p, fd, e); |
| else |
| p->exps->push(e); |
| return 0; |
| } |
| |
| /** |
| * Collects all unit test functions from the given array of symbols. |
| * |
| * This is a helper function used by the implementation of __traits(getUnitTests). |
| * |
| * Input: |
| * symbols array of symbols to collect the functions from |
| * uniqueUnitTests an associative array (should actually be a set) to |
| * keep track of already collected functions. We're |
| * using an AA here to avoid doing a linear search of unitTests |
| * |
| * Output: |
| * unitTests array of DsymbolExp's of the collected unit test functions |
| * uniqueUnitTests updated with symbols from unitTests[ ] |
| */ |
| static void collectUnitTests(Dsymbols *symbols, AA *uniqueUnitTests, Expressions *unitTests) |
| { |
| if (!symbols) |
| return; |
| for (size_t i = 0; i < symbols->length; i++) |
| { |
| Dsymbol *symbol = (*symbols)[i]; |
| UnitTestDeclaration *unitTest = symbol->isUnitTestDeclaration(); |
| if (unitTest) |
| { |
| if (!dmd_aaGetRvalue(uniqueUnitTests, (void *)unitTest)) |
| { |
| FuncAliasDeclaration* ad = new FuncAliasDeclaration(unitTest->ident, unitTest, false); |
| ad->protection = unitTest->protection; |
| Expression* e = new DsymbolExp(Loc(), ad, false); |
| unitTests->push(e); |
| bool* value = (bool*) dmd_aaGet(&uniqueUnitTests, (void *)unitTest); |
| *value = true; |
| } |
| } |
| else |
| { |
| AttribDeclaration *attrDecl = symbol->isAttribDeclaration(); |
| |
| if (attrDecl) |
| { |
| Dsymbols *decl = attrDecl->include(NULL); |
| collectUnitTests(decl, uniqueUnitTests, unitTests); |
| } |
| } |
| } |
| } |
| |
| /*************************************************** |
| * Determine if type t is copyable. |
| * Params: |
| * t = type to check |
| * Returns: |
| * true if we can copy it |
| */ |
| static bool isCopyable(Type *t) |
| { |
| //printf("isCopyable() %s\n", t->toChars()); |
| if (TypeStruct *ts = t->isTypeStruct()) |
| { |
| if (ts->sym->postblit && |
| (ts->sym->postblit->storage_class & STCdisable)) |
| return false; |
| } |
| return true; |
| } |
| |
| /************************ TraitsExp ************************************/ |
| |
| static Expression *True(TraitsExp *e) { return new IntegerExp(e->loc, true, Type::tbool); } |
| static Expression *False(TraitsExp *e) { return new IntegerExp(e->loc, false, Type::tbool); } |
| |
| /************************************** |
| * Convert `Expression` or `Type` to corresponding `Dsymbol`, |
| * additionally strip off expression contexts. |
| * |
| * Some symbol related `__traits` ignore arguments expression contexts. |
| * For example: |
| * struct S { void f() {} } |
| * S s; |
| * pragma(msg, __traits(isNested, s.f)); |
| * // s.f is DotVarExp, but __traits(isNested) needs a FuncDeclaration. |
| * |
| * This is used for that common `__traits` behavior. |
| */ |
| static Dsymbol *getDsymbolWithoutExpCtx(RootObject *oarg) |
| { |
| if (Expression *e = isExpression(oarg)) |
| { |
| if (e->op == TOKdotvar) |
| return ((DotVarExp *)e)->var; |
| if (e->op == TOKdottd) |
| return ((DotTemplateExp *)e)->td; |
| } |
| return getDsymbol(oarg); |
| } |
| |
| /** |
| Gets the function type from a given AST node |
| if the node is a function of some sort. |
| |
| Params: |
| o = an AST node to check for a `TypeFunction` |
| fdp = optional pointer to a function declararion, to be set |
| if `o` is a function declarartion. |
| |
| Returns: |
| a type node if `o` is a declaration of |
| a delegate, function, function-pointer |
| or a variable of the former. Otherwise, `null`. |
| */ |
| static TypeFunction *toTypeFunction(RootObject *o, FuncDeclaration **fdp = NULL) |
| { |
| Dsymbol *s = getDsymbolWithoutExpCtx(o); |
| Type *t = isType(o); |
| TypeFunction *tf = NULL; |
| |
| if (s) |
| { |
| FuncDeclaration *fd = s->isFuncDeclaration(); |
| if (fd) |
| { |
| t = fd->type; |
| if (fdp) |
| *fdp = fd; |
| } |
| else if (VarDeclaration *vd = s->isVarDeclaration()) |
| t = vd->type; |
| } |
| if (t) |
| { |
| if (t->ty == Tfunction) |
| tf = (TypeFunction *)t; |
| else if (t->ty == Tdelegate) |
| tf = (TypeFunction *)t->nextOf(); |
| else if (t->ty == Tpointer && t->nextOf()->ty == Tfunction) |
| tf = (TypeFunction *)t->nextOf(); |
| } |
| |
| return tf; |
| } |
| |
| static bool isTypeArithmetic(Type *t) { return t->isintegral() || t->isfloating(); } |
| static bool isTypeFloating(Type *t) { return t->isfloating(); } |
| static bool isTypeIntegral(Type *t) { return t->isintegral(); } |
| static bool isTypeScalar(Type *t) { return t->isscalar(); } |
| static bool isTypeUnsigned(Type *t) { return t->isunsigned(); } |
| static bool isTypeAssociativeArray(Type *t) { return t->toBasetype()->ty == Taarray; } |
| static bool isTypeStaticArray(Type *t) { return t->toBasetype()->ty == Tsarray; } |
| static bool isTypeAbstractClass(Type *t) { return t->toBasetype()->ty == Tclass && ((TypeClass *)t->toBasetype())->sym->isAbstract(); } |
| static bool isTypeFinalClass(Type *t) { return t->toBasetype()->ty == Tclass && (((TypeClass *)t->toBasetype())->sym->storage_class & STCfinal) != 0; } |
| |
| static Expression *isTypeX(TraitsExp *e, bool (*fp)(Type *t)) |
| { |
| if (!e->args || !e->args->length) |
| return False(e); |
| for (size_t i = 0; i < e->args->length; i++) |
| { |
| Type *t = getType((*e->args)[i]); |
| if (!t || !fp(t)) |
| return False(e); |
| } |
| return True(e); |
| } |
| |
| static bool isDsymDeprecated(Dsymbol *s) { return s->isDeprecated(); } |
| |
| static int fpisTemplate(void *, Dsymbol *s) |
| { |
| if (s->isTemplateDeclaration()) |
| return 1; |
| |
| return 0; |
| } |
| |
| bool isTemplate(Dsymbol *s) |
| { |
| if (!s->toAlias()->isOverloadable()) |
| return false; |
| |
| return overloadApply(s, NULL, &fpisTemplate) != 0; |
| } |
| |
| static Expression *isDsymX(TraitsExp *e, bool (*fp)(Dsymbol *s)) |
| { |
| if (!e->args || !e->args->length) |
| return False(e); |
| for (size_t i = 0; i < e->args->length; i++) |
| { |
| Dsymbol *s = getDsymbolWithoutExpCtx((*e->args)[i]); |
| if (!s || !fp(s)) |
| return False(e); |
| } |
| return True(e); |
| } |
| |
| static bool isFuncAbstractFunction(FuncDeclaration *f) { return f->isAbstract(); } |
| static bool isFuncVirtualFunction(FuncDeclaration *f) { return f->isVirtual(); } |
| static bool isFuncVirtualMethod(FuncDeclaration *f) { return f->isVirtualMethod(); } |
| static bool isFuncFinalFunction(FuncDeclaration *f) { return f->isFinalFunc(); } |
| static bool isFuncStaticFunction(FuncDeclaration *f) { return !f->needThis() && !f->isNested(); } |
| static bool isFuncOverrideFunction(FuncDeclaration *f) { return f->isOverride(); } |
| |
| static Expression *isFuncX(TraitsExp *e, bool (*fp)(FuncDeclaration *f)) |
| { |
| if (!e->args || !e->args->length) |
| return False(e); |
| for (size_t i = 0; i < e->args->length; i++) |
| { |
| Dsymbol *s = getDsymbolWithoutExpCtx((*e->args)[i]); |
| if (!s) |
| return False(e); |
| FuncDeclaration *f = s->isFuncDeclaration(); |
| if (!f || !fp(f)) |
| return False(e); |
| } |
| return True(e); |
| } |
| |
| static bool isDeclDisabled(Declaration *d) { return d->isDisabled(); } |
| static bool isDeclFuture(Declaration *d) { return d->isFuture(); } |
| static bool isDeclRef(Declaration *d) { return d->isRef(); } |
| static bool isDeclOut(Declaration *d) { return d->isOut(); } |
| static bool isDeclLazy(Declaration *d) { return (d->storage_class & STClazy) != 0; } |
| |
| static Expression *isDeclX(TraitsExp *e, bool (*fp)(Declaration *d)) |
| { |
| if (!e->args || !e->args->length) |
| return False(e); |
| for (size_t i = 0; i < e->args->length; i++) |
| { |
| Dsymbol *s = getDsymbolWithoutExpCtx((*e->args)[i]); |
| if (!s) |
| return False(e); |
| Declaration *d = s->isDeclaration(); |
| if (!d || !fp(d)) |
| return False(e); |
| } |
| return True(e); |
| } |
| |
| static bool isPkgModule(Package *p) { return p->isModule() || p->isPackageMod(); } |
| static bool isPkgPackage(Package *p) { return p->isModule() == NULL; } |
| |
| static Expression *isPkgX(TraitsExp *e, bool (*fp)(Package *p)) |
| { |
| if (!e->args || !e->args->length) |
| return False(e); |
| for (size_t i = 0; i < e->args->length; i++) |
| { |
| Dsymbol *s = getDsymbolWithoutExpCtx((*e->args)[i]); |
| if (!s) |
| return False(e); |
| Package *p = resolveIsPackage(s); |
| if (!p || !fp(p)) |
| return False(e); |
| } |
| return True(e); |
| } |
| |
| // callback for TypeFunction::attributesApply |
| struct PushAttributes |
| { |
| Expressions *mods; |
| |
| static int fp(void *param, const char *str) |
| { |
| PushAttributes *p = (PushAttributes *)param; |
| p->mods->push(new StringExp(Loc(), const_cast<char *>(str))); |
| return 0; |
| } |
| }; |
| |
| StringTable traitsStringTable; |
| |
| struct TraitsInitializer |
| { |
| TraitsInitializer(); |
| }; |
| |
| static TraitsInitializer traitsinitializer; |
| |
| TraitsInitializer::TraitsInitializer() |
| { |
| const char* traits[] = { |
| "isAbstractClass", |
| "isArithmetic", |
| "isAssociativeArray", |
| "isDisabled", |
| "isDeprecated", |
| "isFuture", |
| "isFinalClass", |
| "isPOD", |
| "isNested", |
| "isFloating", |
| "isIntegral", |
| "isScalar", |
| "isStaticArray", |
| "isUnsigned", |
| "isVirtualFunction", |
| "isVirtualMethod", |
| "isAbstractFunction", |
| "isFinalFunction", |
| "isOverrideFunction", |
| "isStaticFunction", |
| "isModule", |
| "isPackage", |
| "isRef", |
| "isOut", |
| "isLazy", |
| "isReturnOnStack", |
| "hasMember", |
| "identifier", |
| "getProtection", |
| "getVisibility", |
| "parent", |
| "child", |
| "getLinkage", |
| "getMember", |
| "getOverloads", |
| "getVirtualFunctions", |
| "getVirtualMethods", |
| "classInstanceSize", |
| "allMembers", |
| "derivedMembers", |
| "isSame", |
| "compiles", |
| "getAliasThis", |
| "getAttributes", |
| "getFunctionAttributes", |
| "getFunctionVariadicStyle", |
| "getParameterStorageClasses", |
| "getUnitTests", |
| "getVirtualIndex", |
| "getPointerBitmap", |
| "isZeroInit", |
| "getTargetInfo", |
| "getLocation", |
| "hasPostblit", |
| "isCopyable", |
| NULL |
| }; |
| |
| traitsStringTable._init(56); |
| |
| for (size_t idx = 0;; idx++) |
| { |
| const char *s = traits[idx]; |
| if (!s) break; |
| StringValue *sv = traitsStringTable.insert(s, strlen(s), const_cast<char *>(s)); |
| assert(sv); |
| } |
| } |
| |
| void *trait_search_fp(void *, const char *seed, int* cost) |
| { |
| //printf("trait_search_fp('%s')\n", seed); |
| size_t len = strlen(seed); |
| if (!len) |
| return NULL; |
| |
| *cost = 0; |
| StringValue *sv = traitsStringTable.lookup(seed, len); |
| return sv ? (void*)sv->ptrvalue : NULL; |
| } |
| |
| /** |
| * get an array of size_t values that indicate possible pointer words in memory |
| * if interpreted as the type given as argument |
| * the first array element is the size of the type for independent interpretation |
| * of the array |
| * following elements bits represent one word (4/8 bytes depending on the target |
| * architecture). If set the corresponding memory might contain a pointer/reference. |
| * |
| * [T.sizeof, pointerbit0-31/63, pointerbit32/64-63/128, ...] |
| */ |
| Expression *pointerBitmap(TraitsExp *e) |
| { |
| if (!e->args || e->args->length != 1) |
| { |
| error(e->loc, "a single type expected for trait pointerBitmap"); |
| return new ErrorExp(); |
| } |
| Type *t = getType((*e->args)[0]); |
| if (!t) |
| { |
| error(e->loc, "%s is not a type", (*e->args)[0]->toChars()); |
| return new ErrorExp(); |
| } |
| d_uns64 sz; |
| if (t->ty == Tclass && !((TypeClass*)t)->sym->isInterfaceDeclaration()) |
| sz = ((TypeClass*)t)->sym->AggregateDeclaration::size(e->loc); |
| else |
| sz = t->size(e->loc); |
| if (sz == SIZE_INVALID) |
| return new ErrorExp(); |
| |
| const d_uns64 sz_size_t = Type::tsize_t->size(e->loc); |
| if (sz > UINT64_MAX - sz_size_t) |
| { |
| error(e->loc, "size overflow for type %s", t->toChars()); |
| return new ErrorExp(); |
| } |
| |
| d_uns64 bitsPerWord = sz_size_t * 8; |
| d_uns64 cntptr = (sz + sz_size_t - 1) / sz_size_t; |
| d_uns64 cntdata = (cntptr + bitsPerWord - 1) / bitsPerWord; |
| Array<d_uns64> data; |
| data.setDim((size_t)cntdata); |
| data.zero(); |
| |
| class PointerBitmapVisitor : public Visitor |
| { |
| public: |
| PointerBitmapVisitor(Array<d_uns64>* _data, d_uns64 _sz_size_t) |
| : data(_data), offset(0), sz_size_t(_sz_size_t), error(false) |
| {} |
| |
| void setpointer(d_uns64 off) |
| { |
| d_uns64 ptroff = off / sz_size_t; |
| (*data)[(size_t)(ptroff / (8 * sz_size_t))] |= 1LL << (ptroff % (8 * sz_size_t)); |
| } |
| virtual void visit(Type *t) |
| { |
| Type *tb = t->toBasetype(); |
| if (tb != t) |
| tb->accept(this); |
| } |
| virtual void visit(TypeError *t) { visit((Type *)t); } |
| virtual void visit(TypeNext *) { assert(0); } |
| virtual void visit(TypeBasic *t) |
| { |
| if (t->ty == Tvoid) |
| setpointer(offset); |
| } |
| virtual void visit(TypeVector *) { } |
| virtual void visit(TypeArray *) { assert(0); } |
| virtual void visit(TypeSArray *t) |
| { |
| d_uns64 arrayoff = offset; |
| d_uns64 nextsize = t->next->size(); |
| if (nextsize == SIZE_INVALID) |
| error = true; |
| d_uns64 dim = t->dim->toInteger(); |
| for (d_uns64 i = 0; i < dim; i++) |
| { |
| offset = arrayoff + i * nextsize; |
| t->next->accept(this); |
| } |
| offset = arrayoff; |
| } |
| virtual void visit(TypeDArray *) { setpointer(offset + sz_size_t); } // dynamic array is {length,ptr} |
| virtual void visit(TypeAArray *) { setpointer(offset); } |
| virtual void visit(TypePointer *t) |
| { |
| if (t->nextOf()->ty != Tfunction) // don't mark function pointers |
| setpointer(offset); |
| } |
| virtual void visit(TypeReference *) { setpointer(offset); } |
| virtual void visit(TypeClass *) { setpointer(offset); } |
| virtual void visit(TypeFunction *) { } |
| virtual void visit(TypeDelegate *) { setpointer(offset); } // delegate is {context, function} |
| virtual void visit(TypeQualified *) { assert(0); } // assume resolved |
| virtual void visit(TypeIdentifier *) { assert(0); } |
| virtual void visit(TypeInstance *) { assert(0); } |
| virtual void visit(TypeTypeof *) { assert(0); } |
| virtual void visit(TypeReturn *) { assert(0); } |
| virtual void visit(TypeEnum *t) { visit((Type *)t); } |
| virtual void visit(TypeTuple *t) { visit((Type *)t); } |
| virtual void visit(TypeSlice *) { assert(0); } |
| virtual void visit(TypeNull *) { } // always a null pointer |
| |
| virtual void visit(TypeStruct *t) |
| { |
| d_uns64 structoff = offset; |
| for (size_t i = 0; i < t->sym->fields.length; i++) |
| { |
| VarDeclaration *v = t->sym->fields[i]; |
| offset = structoff + v->offset; |
| if (v->type->ty == Tclass) |
| setpointer(offset); |
| else |
| v->type->accept(this); |
| } |
| offset = structoff; |
| } |
| |
| // a "toplevel" class is treated as an instance, while TypeClass fields are treated as references |
| void visitClass(TypeClass* t) |
| { |
| d_uns64 classoff = offset; |
| |
| // skip vtable-ptr and monitor |
| if (t->sym->baseClass) |
| visitClass((TypeClass*)t->sym->baseClass->type); |
| |
| for (size_t i = 0; i < t->sym->fields.length; i++) |
| { |
| VarDeclaration *v = t->sym->fields[i]; |
| offset = classoff + v->offset; |
| v->type->accept(this); |
| } |
| offset = classoff; |
| } |
| |
| Array<d_uns64>* data; |
| d_uns64 offset; |
| d_uns64 sz_size_t; |
| bool error; |
| }; |
| |
| PointerBitmapVisitor pbv(&data, sz_size_t); |
| if (t->ty == Tclass) |
| pbv.visitClass((TypeClass*)t); |
| else |
| t->accept(&pbv); |
| if (pbv.error) |
| return new ErrorExp(); |
| |
| Expressions* exps = new Expressions; |
| exps->push(new IntegerExp(e->loc, sz, Type::tsize_t)); |
| for (d_uns64 i = 0; i < cntdata; i++) |
| exps->push(new IntegerExp(e->loc, data[(size_t)i], Type::tsize_t)); |
| |
| ArrayLiteralExp* ale = new ArrayLiteralExp(e->loc, Type::tsize_t->sarrayOf(cntdata + 1), exps); |
| return ale; |
| } |
| |
| static Expression *dimError(TraitsExp *e, int expected, int dim) |
| { |
| e->error("expected %d arguments for `%s` but had %d", expected, e->ident->toChars(), dim); |
| return new ErrorExp(); |
| } |
| |
| Expression *semanticTraits(TraitsExp *e, Scope *sc) |
| { |
| if (e->ident != Id::compiles && |
| e->ident != Id::isSame && |
| e->ident != Id::identifier && |
| e->ident != Id::getProtection && e->ident != Id::getVisibility && |
| e->ident != Id::getAttributes) |
| { |
| // Pretend we're in a deprecated scope so that deprecation messages |
| // aren't triggered when checking if a symbol is deprecated |
| const StorageClass save = sc->stc; |
| if (e->ident == Id::isDeprecated) |
| sc->stc |= STCdeprecated; |
| if (!TemplateInstance::semanticTiargs(e->loc, sc, e->args, 1)) |
| { |
| sc->stc = save; |
| return new ErrorExp(); |
| } |
| sc->stc = save; |
| } |
| size_t dim = e->args ? e->args->length : 0; |
| |
| if (e->ident == Id::isArithmetic) |
| { |
| return isTypeX(e, &isTypeArithmetic); |
| } |
| else if (e->ident == Id::isFloating) |
| { |
| return isTypeX(e, &isTypeFloating); |
| } |
| else if (e->ident == Id::isIntegral) |
| { |
| return isTypeX(e, &isTypeIntegral); |
| } |
| else if (e->ident == Id::isScalar) |
| { |
| return isTypeX(e, &isTypeScalar); |
| } |
| else if (e->ident == Id::isUnsigned) |
| { |
| return isTypeX(e, &isTypeUnsigned); |
| } |
| else if (e->ident == Id::isAssociativeArray) |
| { |
| return isTypeX(e, &isTypeAssociativeArray); |
| } |
| else if (e->ident == Id::isDeprecated) |
| { |
| return isDsymX(e, &isDsymDeprecated); |
| } |
| else if (e->ident == Id::isFuture) |
| { |
| return isDeclX(e, &isDeclFuture); |
| } |
| else if (e->ident == Id::isStaticArray) |
| { |
| return isTypeX(e, &isTypeStaticArray); |
| } |
| else if (e->ident == Id::isAbstractClass) |
| { |
| return isTypeX(e, &isTypeAbstractClass); |
| } |
| else if (e->ident == Id::isFinalClass) |
| { |
| return isTypeX(e, &isTypeFinalClass); |
| } |
| else if (e->ident == Id::isTemplate) |
| { |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| return isDsymX(e, &isTemplate); |
| } |
| else if (e->ident == Id::isPOD) |
| { |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| RootObject *o = (*e->args)[0]; |
| Type *t = isType(o); |
| if (!t) |
| { |
| e->error("type expected as second argument of __traits %s instead of %s", |
| e->ident->toChars(), o->toChars()); |
| return new ErrorExp(); |
| } |
| |
| Type *tb = t->baseElemOf(); |
| if (StructDeclaration *sd = (tb->ty == Tstruct) ? ((TypeStruct *)tb)->sym : NULL) |
| { |
| return (sd->isPOD()) ? True(e) : False(e); |
| } |
| return True(e); |
| } |
| else if (e->ident == Id::hasPostblit) |
| { |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| RootObject *o = (*e->args)[0]; |
| Type *t = isType(o); |
| if (!t) |
| { |
| e->error("type expected as second argument of __traits %s instead of %s", |
| e->ident->toChars(), o->toChars()); |
| return new ErrorExp(); |
| } |
| |
| Type *tb = t->baseElemOf(); |
| if (StructDeclaration *sd = (tb->ty == Tstruct) ? ((TypeStruct *)tb)->sym : NULL) |
| { |
| return sd->postblit ? True(e) : False(e); |
| } |
| return False(e); |
| } |
| else if (e->ident == Id::isCopyable) |
| { |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| RootObject *o = (*e->args)[0]; |
| Type *t = isType(o); |
| if (!t) |
| { |
| e->error("type expected as second argument of __traits %s instead of %s", |
| e->ident->toChars(), o->toChars()); |
| return new ErrorExp(); |
| } |
| |
| return isCopyable(t) ? True(e) : False(e); |
| } |
| else if (e->ident == Id::isNested) |
| { |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| RootObject *o = (*e->args)[0]; |
| Dsymbol *s = getDsymbolWithoutExpCtx(o); |
| if (!s) |
| { |
| } |
| else if (AggregateDeclaration *a = s->isAggregateDeclaration()) |
| { |
| return a->isNested() ? True(e) : False(e); |
| } |
| else if (FuncDeclaration *f = s->isFuncDeclaration()) |
| { |
| return f->isNested() ? True(e) : False(e); |
| } |
| |
| e->error("aggregate or function expected instead of `%s`", o->toChars()); |
| return new ErrorExp(); |
| } |
| else if (e->ident == Id::isDisabled) |
| { |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| return isDeclX(e, &isDeclDisabled); |
| } |
| else if (e->ident == Id::isAbstractFunction) |
| { |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| return isFuncX(e, &isFuncAbstractFunction); |
| } |
| else if (e->ident == Id::isVirtualFunction) |
| { |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| return isFuncX(e, &isFuncVirtualFunction); |
| } |
| else if (e->ident == Id::isVirtualMethod) |
| { |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| return isFuncX(e, &isFuncVirtualMethod); |
| } |
| else if (e->ident == Id::isFinalFunction) |
| { |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| return isFuncX(e, &isFuncFinalFunction); |
| } |
| else if (e->ident == Id::isOverrideFunction) |
| { |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| return isFuncX(e, &isFuncOverrideFunction); |
| } |
| else if (e->ident == Id::isStaticFunction) |
| { |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| return isFuncX(e, &isFuncStaticFunction); |
| } |
| else if (e->ident == Id::isModule) |
| { |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| return isPkgX(e, &isPkgModule); |
| } |
| else if (e->ident == Id::isPackage) |
| { |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| return isPkgX(e, &isPkgPackage); |
| } |
| else if (e->ident == Id::isRef) |
| { |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| return isDeclX(e, &isDeclRef); |
| } |
| else if (e->ident == Id::isOut) |
| { |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| return isDeclX(e, &isDeclOut); |
| } |
| else if (e->ident == Id::isLazy) |
| { |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| return isDeclX(e, &isDeclLazy); |
| } |
| else if (e->ident == Id::identifier) |
| { |
| // Get identifier for symbol as a string literal |
| /* Specify 0 for bit 0 of the flags argument to semanticTiargs() so that |
| * a symbol should not be folded to a constant. |
| * Bit 1 means don't convert Parameter to Type if Parameter has an identifier |
| */ |
| if (!TemplateInstance::semanticTiargs(e->loc, sc, e->args, 2)) |
| return new ErrorExp(); |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| RootObject *o = (*e->args)[0]; |
| Identifier *id = NULL; |
| if (Parameter *po = isParameter(o)) |
| { |
| if (!po->ident) |
| { |
| e->error("argument `%s` has no identifier", po->type->toChars()); |
| return new ErrorExp(); |
| } |
| id = po->ident; |
| } |
| else |
| { |
| Dsymbol *s = getDsymbolWithoutExpCtx(o); |
| if (!s || !s->ident) |
| { |
| e->error("argument %s has no identifier", o->toChars()); |
| return new ErrorExp(); |
| } |
| id = s->ident; |
| } |
| |
| StringExp *se = new StringExp(e->loc, const_cast<char *>(id->toChars())); |
| return expressionSemantic(se, sc); |
| } |
| else if (e->ident == Id::getProtection || e->ident == Id::getVisibility) |
| { |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| Scope *sc2 = sc->push(); |
| sc2->flags = sc->flags | SCOPEnoaccesscheck | SCOPEignoresymbolvisibility; |
| bool ok = TemplateInstance::semanticTiargs(e->loc, sc2, e->args, 1); |
| sc2->pop(); |
| if (!ok) |
| return new ErrorExp(); |
| |
| RootObject *o = (*e->args)[0]; |
| Dsymbol *s = getDsymbolWithoutExpCtx(o); |
| if (!s) |
| { |
| if (!isError(o)) |
| e->error("argument %s has no protection", o->toChars()); |
| return new ErrorExp(); |
| } |
| if (s->semanticRun == PASSinit) |
| dsymbolSemantic(s, NULL); |
| |
| const char *protName = protectionToChars(s->prot().kind); // TODO: How about package(names) |
| assert(protName); |
| StringExp *se = new StringExp(e->loc, const_cast<char *>(protName)); |
| return expressionSemantic(se, sc); |
| } |
| else if (e->ident == Id::parent) |
| { |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| RootObject *o = (*e->args)[0]; |
| Dsymbol *s = getDsymbolWithoutExpCtx(o); |
| if (s) |
| { |
| if (FuncDeclaration *fd = s->isFuncDeclaration()) // Bugzilla 8943 |
| s = fd->toAliasFunc(); |
| if (!s->isImport()) // Bugzilla 8922 |
| s = s->toParent(); |
| } |
| if (!s || s->isImport()) |
| { |
| e->error("argument %s has no parent", o->toChars()); |
| return new ErrorExp(); |
| } |
| |
| if (FuncDeclaration *f = s->isFuncDeclaration()) |
| { |
| if (TemplateDeclaration *td = getFuncTemplateDecl(f)) |
| { |
| if (td->overroot) // if not start of overloaded list of TemplateDeclaration's |
| td = td->overroot; // then get the start |
| Expression *ex = new TemplateExp(e->loc, td, f); |
| ex = expressionSemantic(ex, sc); |
| return ex; |
| } |
| |
| if (FuncLiteralDeclaration *fld = f->isFuncLiteralDeclaration()) |
| { |
| // Directly translate to VarExp instead of FuncExp |
| Expression *ex = new VarExp(e->loc, fld, true); |
| return expressionSemantic(ex, sc); |
| } |
| } |
| |
| return resolve(e->loc, sc, s, false); |
| } |
| else if (e->ident == Id::child) |
| { |
| if (dim != 2) |
| return dimError(e, 2, dim); |
| |
| Expression *ex; |
| RootObject *op = (*e->args)[0]; |
| if (Dsymbol *symp = getDsymbol(op)) |
| ex = new DsymbolExp(e->loc, symp); |
| else if (Expression *exp = isExpression(op)) |
| ex = exp; |
| else |
| { |
| e->error("symbol or expression expected as first argument of __traits `child` instead of `%s`", op->toChars()); |
| return new ErrorExp(); |
| } |
| |
| ex = expressionSemantic(ex, sc); |
| RootObject *oc = (*e->args)[1]; |
| Dsymbol *symc = getDsymbol(oc); |
| if (!symc) |
| { |
| e->error("symbol expected as second argument of __traits `child` instead of `%s`", oc->toChars()); |
| return new ErrorExp(); |
| } |
| |
| if (Declaration *d = symc->isDeclaration()) |
| ex = new DotVarExp(e->loc, ex, d); |
| else if (TemplateDeclaration *td = symc->isTemplateDeclaration()) |
| ex = new DotExp(e->loc, ex, new TemplateExp(e->loc, td)); |
| else if (ScopeDsymbol *ti = symc->isScopeDsymbol()) |
| ex = new DotExp(e->loc, ex, new ScopeExp(e->loc, ti)); |
| else |
| assert(0); |
| |
| ex = expressionSemantic(ex, sc); |
| return ex; |
| } |
| else if (e->ident == Id::toType) |
| { |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| Expression *ex = isExpression((*e->args)[0]); |
| if (!ex) |
| { |
| e->error("expression expected as second argument of __traits `%s`", e->ident->toChars()); |
| return new ErrorExp(); |
| } |
| ex = ex->ctfeInterpret(); |
| |
| StringExp *se = semanticString(sc, ex, "__traits(toType, string)"); |
| if (!se) |
| { |
| return new ErrorExp(); |
| } |
| Type *t = decoToType(se->toUTF8(sc)->toPtr()); |
| if (!t) |
| { |
| e->error("cannot determine `%s`", e->toChars()); |
| return new ErrorExp(); |
| } |
| ex = new TypeExp(e->loc, t); |
| ex = expressionSemantic(ex, sc); |
| return ex; |
| } |
| else if (e->ident == Id::hasMember || |
| e->ident == Id::getMember || |
| e->ident == Id::getOverloads || |
| e->ident == Id::getVirtualMethods || |
| e->ident == Id::getVirtualFunctions) |
| { |
| if (dim != 2 && !(dim == 3 && e->ident == Id::getOverloads)) |
| return dimError(e, 2, dim); |
| |
| RootObject *o = (*e->args)[0]; |
| Expression *ex = isExpression((*e->args)[1]); |
| if (!ex) |
| { |
| e->error("expression expected as second argument of __traits %s", e->ident->toChars()); |
| return new ErrorExp(); |
| } |
| ex = ex->ctfeInterpret(); |
| |
| bool includeTemplates = false; |
| if (dim == 3 && e->ident == Id::getOverloads) |
| { |
| Expression *b = isExpression((*e->args)[2]); |
| b = b->ctfeInterpret(); |
| if (!b->type->equals(Type::tbool)) |
| { |
| e->error("`bool` expected as third argument of `__traits(getOverloads)`, not `%s` of type `%s`", b->toChars(), b->type->toChars()); |
| return new ErrorExp(); |
| } |
| includeTemplates = b->isBool(true); |
| } |
| |
| StringExp *se = ex->toStringExp(); |
| if (!se || se->len == 0) |
| { |
| e->error("string expected as second argument of __traits %s instead of %s", e->ident->toChars(), ex->toChars()); |
| return new ErrorExp(); |
| } |
| se = se->toUTF8(sc); |
| |
| if (se->sz != 1) |
| { |
| e->error("string must be chars"); |
| return new ErrorExp(); |
| } |
| Identifier *id = Identifier::idPool((char *)se->string, se->len); |
| |
| /* Prefer dsymbol, because it might need some runtime contexts. |
| */ |
| Dsymbol *sym = getDsymbol(o); |
| if (sym) |
| { |
| if (e->ident == Id::hasMember) |
| { |
| if (sym->search(e->loc, id) != NULL) |
| return True(e); |
| } |
| ex = new DsymbolExp(e->loc, sym); |
| ex = new DotIdExp(e->loc, ex, id); |
| } |
| else if (Type *t = isType(o)) |
| ex = typeDotIdExp(e->loc, t, id); |
| else if (Expression *ex2 = isExpression(o)) |
| ex = new DotIdExp(e->loc, ex2, id); |
| else |
| { |
| e->error("invalid first argument"); |
| return new ErrorExp(); |
| } |
| |
| // ignore symbol visibility and disable access checks for these traits |
| Scope *scx = sc->push(); |
| scx->flags |= SCOPEignoresymbolvisibility | SCOPEnoaccesscheck; |
| |
| if (e->ident == Id::hasMember) |
| { |
| /* Take any errors as meaning it wasn't found |
| */ |
| ex = trySemantic(ex, scx); |
| scx->pop(); |
| return ex ? True(e) : False(e); |
| } |
| else if (e->ident == Id::getMember) |
| { |
| if (ex->op == TOKdotid) |
| // Prevent semantic() from replacing Symbol with its initializer |
| ((DotIdExp *)ex)->wantsym = true; |
| ex = expressionSemantic(ex, scx); |
| scx->pop(); |
| return ex; |
| } |
| else if (e->ident == Id::getVirtualFunctions || |
| e->ident == Id::getVirtualMethods || |
| e->ident == Id::getOverloads) |
| { |
| unsigned errors = global.errors; |
| Expression *eorig = ex; |
| ex = expressionSemantic(ex, scx); |
| if (errors < global.errors) |
| e->error("%s cannot be resolved", eorig->toChars()); |
| //ex->print(); |
| |
| /* Create tuple of functions of ex |
| */ |
| Expressions *exps = new Expressions(); |
| Dsymbol *f; |
| if (ex->op == TOKvar) |
| { |
| VarExp *ve = (VarExp *)ex; |
| f = ve->var->isFuncDeclaration(); |
| ex = NULL; |
| } |
| else if (ex->op == TOKdotvar) |
| { |
| DotVarExp *dve = (DotVarExp *)ex; |
| f = dve->var->isFuncDeclaration(); |
| if (dve->e1->op == TOKdottype || dve->e1->op == TOKthis) |
| ex = NULL; |
| else |
| ex = dve->e1; |
| } |
| else if (ex->op == TOKtemplate) |
| { |
| TemplateExp *te = (TemplateExp *)ex; |
| TemplateDeclaration *td = te->td; |
| f = td; |
| if (td && td->funcroot) |
| f = td->funcroot; |
| ex = NULL; |
| } |
| else |
| f = NULL; |
| Ptrait p; |
| p.sym = sym; |
| p.exps = exps; |
| p.e1 = ex; |
| p.ident = e->ident; |
| p.includeTemplates = includeTemplates; |
| AA *funcTypeHash = NULL; |
| p.funcTypeHash = &funcTypeHash; |
| |
| InterfaceDeclaration *ifd = NULL; |
| if (sym) |
| ifd = sym->isInterfaceDeclaration(); |
| // If the symbol passed as a parameter is an |
| // interface that inherits other interfaces |
| if (ifd && ifd->interfaces.length) |
| { |
| // check the overloads of each inherited interface individually |
| for (size_t i = 0; i < ifd->interfaces.length; i++) |
| { |
| BaseClass *bc = ifd->interfaces.ptr[i]; |
| if (Dsymbol *fd = bc->sym->search(e->loc, f->ident)) |
| overloadApply(fd, &p, &fptraits); |
| } |
| } |
| else |
| overloadApply(f, &p, &fptraits); |
| |
| ex = new TupleExp(e->loc, exps); |
| ex = expressionSemantic(ex, scx); |
| scx->pop(); |
| return ex; |
| } |
| else |
| assert(0); |
| } |
| else if (e->ident == Id::classInstanceSize) |
| { |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| RootObject *o = (*e->args)[0]; |
| Dsymbol *s = getDsymbol(o); |
| ClassDeclaration *cd = s ? s->isClassDeclaration() : NULL; |
| if (!cd) |
| { |
| e->error("first argument is not a class"); |
| return new ErrorExp(); |
| } |
| if (cd->sizeok != SIZEOKdone) |
| { |
| cd->size(cd->loc); |
| } |
| if (cd->sizeok != SIZEOKdone) |
| { |
| e->error("%s %s is forward referenced", cd->kind(), cd->toChars()); |
| return new ErrorExp(); |
| } |
| |
| return new IntegerExp(e->loc, cd->structsize, Type::tsize_t); |
| } |
| else if (e->ident == Id::getAliasThis) |
| { |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| RootObject *o = (*e->args)[0]; |
| Dsymbol *s = getDsymbol(o); |
| AggregateDeclaration *ad = s ? s->isAggregateDeclaration() : NULL; |
| if (!ad) |
| { |
| e->error("argument is not an aggregate type"); |
| return new ErrorExp(); |
| } |
| |
| Expressions *exps = new Expressions(); |
| if (ad->aliasthis) |
| exps->push(new StringExp(e->loc, const_cast<char *>(ad->aliasthis->ident->toChars()))); |
| Expression *ex = new TupleExp(e->loc, exps); |
| ex = expressionSemantic(ex, sc); |
| return ex; |
| } |
| else if (e->ident == Id::getAttributes) |
| { |
| /* Specify 0 for bit 0 of the flags argument to semanticTiargs() so that |
| * a symbol should not be folded to a constant. |
| * Bit 1 means don't convert Parameter to Type if Parameter has an identifier |
| */ |
| if (!TemplateInstance::semanticTiargs(e->loc, sc, e->args, 3)) |
| return new ErrorExp(); |
| |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| RootObject *o = (*e->args)[0]; |
| Parameter *po = isParameter(o); |
| Dsymbol *s = getDsymbolWithoutExpCtx(o); |
| UserAttributeDeclaration *udad = NULL; |
| if (po) |
| { |
| udad = po->userAttribDecl; |
| } |
| else if (s) |
| { |
| if (Import *imp = s->isImport()) |
| { |
| s = imp->mod; |
| } |
| //printf("getAttributes %s, attrs = %p, scope = %p\n", s->toChars(), s->userAttribDecl, s->_scope); |
| udad = s->userAttribDecl; |
| } |
| else |
| { |
| e->error("first argument is not a symbol"); |
| return new ErrorExp(); |
| } |
| |
| Expressions *exps = udad ? udad->getAttributes() : new Expressions(); |
| TupleExp *tup = new TupleExp(e->loc, exps); |
| return expressionSemantic(tup, sc); |
| } |
| else if (e->ident == Id::getFunctionAttributes) |
| { |
| /* extract all function attributes as a tuple (const/shared/inout/pure/nothrow/etc) except UDAs. |
| * https://dlang.org/spec/traits.html#getFunctionAttributes |
| */ |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| TypeFunction *tf = toTypeFunction((*e->args)[0]); |
| |
| if (!tf) |
| { |
| e->error("first argument is not a function"); |
| return new ErrorExp(); |
| } |
| |
| Expressions *mods = new Expressions(); |
| PushAttributes pa; |
| pa.mods = mods; |
| tf->modifiersApply(&pa, &PushAttributes::fp); |
| tf->attributesApply(&pa, &PushAttributes::fp, TRUSTformatSystem); |
| |
| TupleExp *tup = new TupleExp(e->loc, mods); |
| return expressionSemantic(tup, sc); |
| } |
| else if (e->ident == Id::isReturnOnStack) |
| { |
| /* Extract as a boolean if function return value is on the stack |
| * https://dlang.org/spec/traits.html#isReturnOnStack |
| */ |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| RootObject *o = (*e->args)[0]; |
| FuncDeclaration *fd = NULL; |
| TypeFunction *tf = toTypeFunction(o, &fd); |
| |
| if (!tf) |
| { |
| e->error("argument to `__traits(isReturnOnStack, %s)` is not a function", o->toChars()); |
| return new ErrorExp(); |
| } |
| |
| bool value = target.isReturnOnStack(tf, fd && fd->needThis()); |
| return new IntegerExp(e->loc, value, Type::tbool); |
| } |
| else if (e->ident == Id::getFunctionVariadicStyle) |
| { |
| /* Accept a symbol or a type. Returns one of the following: |
| * "none" not a variadic function |
| * "argptr" extern(D) void dstyle(...), use `__argptr` and `__arguments` |
| * "stdarg" extern(C) void cstyle(int, ...), use core.stdc.stdarg |
| * "typesafe" void typesafe(T[] ...) |
| */ |
| // get symbol linkage as a string |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| LINK link; |
| VarArg varargs; |
| RootObject *o = (*e->args)[0]; |
| FuncDeclaration *fd = NULL; |
| TypeFunction *tf = toTypeFunction(o, &fd); |
| |
| if (tf) |
| { |
| link = tf->linkage; |
| varargs = tf->parameterList.varargs; |
| } |
| else |
| { |
| if (!fd) |
| { |
| e->error("argument to `__traits(getFunctionVariadicStyle, %s)` is not a function", o->toChars()); |
| return new ErrorExp(); |
| } |
| link = fd->linkage; |
| varargs = fd->getParameterList().varargs; |
| } |
| const char *style; |
| switch (varargs) |
| { |
| case 0: style = "none"; break; |
| case 1: style = (link == LINKd) ? "argptr" |
| : "stdarg"; break; |
| case 2: style = "typesafe"; break; |
| default: |
| assert(0); |
| } |
| StringExp *se = new StringExp(e->loc, const_cast<char*>(style)); |
| return expressionSemantic(se, sc); |
| } |
| else if (e->ident == Id::getParameterStorageClasses) |
| { |
| /* Accept a function symbol or a type, followed by a parameter index. |
| * Returns a tuple of strings of the parameter's storage classes. |
| */ |
| // get symbol linkage as a string |
| if (dim != 2) |
| return dimError(e, 2, dim); |
| |
| RootObject *o = (*e->args)[0]; |
| RootObject *o1 = (*e->args)[1]; |
| |
| FuncDeclaration *fd = NULL; |
| TypeFunction *tf = toTypeFunction(o, &fd); |
| |
| ParameterList fparams; |
| if (tf) |
| { |
| fparams = tf->parameterList; |
| } |
| else |
| { |
| if (!fd) |
| { |
| e->error("first argument to `__traits(getParameterStorageClasses, %s, %s)` is not a function", |
| o->toChars(), o1->toChars()); |
| return new ErrorExp(); |
| } |
| fparams = fd->getParameterList(); |
| } |
| |
| StorageClass stc; |
| |
| // Set stc to storage class of the ith parameter |
| Expression *ex = isExpression((*e->args)[1]); |
| if (!ex) |
| { |
| e->error("expression expected as second argument of `__traits(getParameterStorageClasses, %s, %s)`", |
| o->toChars(), o1->toChars()); |
| return new ErrorExp(); |
| } |
| ex = ex->ctfeInterpret(); |
| uinteger_t ii = ex->toUInteger(); |
| if (ii >= fparams.length()) |
| { |
| e->error("parameter index must be in range 0..%u not %s", (unsigned)fparams.length(), ex->toChars()); |
| return new ErrorExp(); |
| } |
| |
| unsigned n = (unsigned)ii; |
| Parameter *p = fparams[n]; |
| stc = p->storageClass; |
| |
| // This mirrors hdrgen.visit(Parameter p) |
| if (p->type && p->type->mod & MODshared) |
| stc &= ~STCshared; |
| |
| Expressions *exps = new Expressions; |
| |
| if (stc & STCauto) |
| exps->push(new StringExp(e->loc, const_cast<char *>("auto"))); |
| if (stc & STCreturn) |
| exps->push(new StringExp(e->loc, const_cast<char *>("return"))); |
| |
| if (stc & STCout) |
| exps->push(new StringExp(e->loc, const_cast<char *>("out"))); |
| else if (stc & STCref) |
| exps->push(new StringExp(e->loc, const_cast<char *>("ref"))); |
| else if (stc & STCin) |
| exps->push(new StringExp(e->loc, const_cast<char *>("in"))); |
| else if (stc & STClazy) |
| exps->push(new StringExp(e->loc, const_cast<char *>("lazy"))); |
| else if (stc & STCalias) |
| exps->push(new StringExp(e->loc, const_cast<char *>("alias"))); |
| |
| if (stc & STCconst) |
| exps->push(new StringExp(e->loc, const_cast<char *>("const"))); |
| if (stc & STCimmutable) |
| exps->push(new StringExp(e->loc, const_cast<char *>("immutable"))); |
| if (stc & STCwild) |
| exps->push(new StringExp(e->loc, const_cast<char *>("inout"))); |
| if (stc & STCshared) |
| exps->push(new StringExp(e->loc, const_cast<char *>("shared"))); |
| if (stc & STCscope && !(stc & STCscopeinferred)) |
| exps->push(new StringExp(e->loc, const_cast<char *>("scope"))); |
| |
| TupleExp *tup = new TupleExp(e->loc, exps); |
| return expressionSemantic(tup, sc); |
| } |
| else if (e->ident == Id::getLinkage) |
| { |
| // get symbol linkage as a string |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| LINK link; |
| RootObject *o = (*e->args)[0]; |
| |
| TypeFunction *tf = toTypeFunction(o); |
| |
| if (tf) |
| link = tf->linkage; |
| else |
| { |
| Dsymbol *s = getDsymbol(o); |
| Declaration *d = NULL; |
| AggregateDeclaration *ad = NULL; |
| if (!s || ((d = s->isDeclaration()) == NULL |
| && (ad = s->isAggregateDeclaration()) == NULL)) |
| { |
| e->error("argument to `__traits(getLinkage, %s)` is not a declaration", o->toChars()); |
| return new ErrorExp(); |
| } |
| if (d != NULL) |
| link = d->linkage; |
| else |
| { |
| switch (ad->classKind) |
| { |
| case ClassKind::d: |
| link = LINKd; |
| break; |
| case ClassKind::cpp: |
| link = LINKcpp; |
| break; |
| case ClassKind::objc: |
| link = LINKobjc; |
| break; |
| default: |
| assert(0); |
| } |
| } |
| } |
| const char *linkage = linkageToChars(link); |
| StringExp *se = new StringExp(e->loc, const_cast<char *>(linkage)); |
| return expressionSemantic(se, sc); |
| } |
| else if (e->ident == Id::allMembers || |
| e->ident == Id::derivedMembers) |
| { |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| RootObject *o = (*e->args)[0]; |
| Dsymbol *s = getDsymbol(o); |
| if (!s) |
| { |
| e->error("argument has no members"); |
| return new ErrorExp(); |
| } |
| if (Import *imp = s->isImport()) |
| { |
| // Bugzilla 9692 |
| s = imp->mod; |
| } |
| |
| // https://issues.dlang.org/show_bug.cgi?id=16044 |
| if (Package *p = s->isPackage()) |
| { |
| if (Module *pm = p->isPackageMod()) |
| s = pm; |
| } |
| |
| ScopeDsymbol *sds = s->isScopeDsymbol(); |
| if (!sds || sds->isTemplateDeclaration()) |
| { |
| e->error("%s %s has no members", s->kind(), s->toChars()); |
| return new ErrorExp(); |
| } |
| |
| // use a struct as local function |
| struct PushIdentsDg |
| { |
| ScopeDsymbol *sds; |
| Identifiers *idents; |
| |
| static int dg(void *ctx, size_t, Dsymbol *sm) |
| { |
| if (!sm) |
| return 1; |
| |
| // skip local symbols, such as static foreach loop variables |
| if (Declaration *decl = sm->isDeclaration()) |
| { |
| if (decl->storage_class & STClocal) |
| { |
| return 0; |
| } |
| } |
| |
| // https://issues.dlang.org/show_bug.cgi?id=20915 |
| // skip version and debug identifiers |
| if (sm->isVersionSymbol() || sm->isDebugSymbol()) |
| return 0; |
| |
| //printf("\t[%i] %s %s\n", i, sm->kind(), sm->toChars()); |
| if (sm->ident) |
| { |
| // https://issues.dlang.org/show_bug.cgi?id=10096 |
| // https://issues.dlang.org/show_bug.cgi?id=10100 |
| // Skip over internal members in __traits(allMembers) |
| if ((sm->isCtorDeclaration() && sm->ident != Id::ctor) || |
| (sm->isDtorDeclaration() && sm->ident != Id::dtor) || |
| (sm->isPostBlitDeclaration() && sm->ident != Id::postblit) || |
| sm->isInvariantDeclaration() || |
| sm->isUnitTestDeclaration()) |
| { |
| return 0; |
| } |
| |
| if (sm->ident == Id::empty) |
| { |
| return 0; |
| } |
| if (sm->isTypeInfoDeclaration()) // Bugzilla 15177 |
| return 0; |
| PushIdentsDg *pid = (PushIdentsDg *)ctx; |
| if (!pid->sds->isModule() && sm->isImport()) // Bugzilla 17057 |
| return 0; |
| |
| //printf("\t%s\n", sm->ident->toChars()); |
| Identifiers *idents = pid->idents; |
| |
| /* Skip if already present in idents[] |
| */ |
| for (size_t j = 0; j < idents->length; j++) |
| { |
| Identifier *id = (*idents)[j]; |
| if (id == sm->ident) |
| return 0; |
| } |
| |
| idents->push(sm->ident); |
| } |
| else |
| { |
| EnumDeclaration *ed = sm->isEnumDeclaration(); |
| if (ed) |
| { |
| ScopeDsymbol_foreach(NULL, ed->members, &PushIdentsDg::dg, ctx); |
| } |
| } |
| return 0; |
| } |
| }; |
| |
| Identifiers *idents = new Identifiers; |
| PushIdentsDg ctx; |
| ctx.sds = sds; |
| ctx.idents = idents; |
| ScopeDsymbol_foreach(sc, sds->members, &PushIdentsDg::dg, &ctx); |
| ClassDeclaration *cd = sds->isClassDeclaration(); |
| if (cd && e->ident == Id::allMembers) |
| { |
| if (cd->semanticRun < PASSsemanticdone) |
| dsymbolSemantic(cd, NULL); // Bugzilla 13668: Try to resolve forward reference |
| |
| struct PushBaseMembers |
| { |
| static void dg(ClassDeclaration *cd, PushIdentsDg *ctx) |
| { |
| for (size_t i = 0; i < cd->baseclasses->length; i++) |
| { |
| ClassDeclaration *cb = (*cd->baseclasses)[i]->sym; |
| assert(cb); |
| ScopeDsymbol_foreach(NULL, cb->members, &PushIdentsDg::dg, ctx); |
| if (cb->baseclasses->length) |
| dg(cb, ctx); |
| } |
| } |
| }; |
| PushBaseMembers::dg(cd, &ctx); |
| } |
| |
| // Turn Identifiers into StringExps reusing the allocated array |
| assert(sizeof(Expressions) == sizeof(Identifiers)); |
| Expressions *exps = (Expressions *)idents; |
| for (size_t i = 0; i < idents->length; i++) |
| { |
| Identifier *id = (*idents)[i]; |
| StringExp *se = new StringExp(e->loc, const_cast<char *>(id->toChars())); |
| (*exps)[i] = se; |
| } |
| |
| /* Making this a tuple is more flexible, as it can be statically unrolled. |
| * To make an array literal, enclose __traits in [ ]: |
| * [ __traits(allMembers, ...) ] |
| */ |
| Expression *ex = new TupleExp(e->loc, exps); |
| ex = expressionSemantic(ex, sc); |
| return ex; |
| } |
| else if (e->ident == Id::compiles) |
| { |
| /* Determine if all the objects - types, expressions, or symbols - |
| * compile without error |
| */ |
| if (!dim) |
| return False(e); |
| |
| for (size_t i = 0; i < dim; i++) |
| { |
| unsigned errors = global.startGagging(); |
| Scope *sc2 = sc->push(); |
| sc2->tinst = NULL; |
| sc2->minst = NULL; |
| sc2->flags = (sc->flags & ~(SCOPEctfe | SCOPEcondition)) | SCOPEcompile | SCOPEfullinst; |
| bool err = false; |
| |
| RootObject *o = (*e->args)[i]; |
| Type *t = isType(o); |
| while (t) |
| { |
| if (TypeMixin *tm = t->isTypeMixin()) |
| { |
| /* The mixin string could be a type or an expression. |
| * Have to try compiling it to see. |
| */ |
| OutBuffer buf; |
| if (expressionsToString(buf, sc, tm->exps)) |
| { |
| err = true; |
| break; |
| } |
| const size_t len = buf.length(); |
| const char *str = buf.extractChars(); |
| Parser p(e->loc, sc->_module, (const utf8_t *)str, len, false); |
| p.nextToken(); |
| //printf("p.loc.linnum = %d\n", p.loc.linnum); |
| |
| o = p.parseTypeOrAssignExp(TOKeof); |
| if (p.errors || p.token.value != TOKeof) |
| { |
| err = true; |
| break; |
| } |
| t = isType(o); |
| } |
| else |
| break; |
| } |
| |
| if (!err) |
| { |
| Expression *ex = t ? typeToExpression(t) : isExpression(o); |
| if (!ex && t) |
| { |
| Dsymbol *s; |
| t->resolve(e->loc, sc2, &ex, &t, &s); |
| if (t) |
| { |
| typeSemantic(t, e->loc, sc2); |
| if (t->ty == Terror) |
| err = true; |
| } |
| else if (s && s->errors) |
| err = true; |
| } |
| if (ex) |
| { |
| ex = expressionSemantic(ex, sc2); |
| ex = resolvePropertiesOnly(sc2, ex); |
| ex = ex->optimize(WANTvalue); |
| if (sc2->func && sc2->func->type->ty == Tfunction) |
| { |
| TypeFunction *tf = (TypeFunction *)sc2->func->type; |
| canThrow(ex, sc2->func, tf->isnothrow); |
| } |
| ex = checkGC(sc2, ex); |
| if (ex->op == TOKerror) |
| err = true; |
| } |
| } |
| |
| // Carefully detach the scope from the parent and throw it away as |
| // we only need it to evaluate the expression |
| // https://issues.dlang.org/show_bug.cgi?id=15428 |
| freeFieldinit(sc2); |
| sc2->enclosing = NULL; |
| sc2->pop(); |
| |
| if (global.endGagging(errors) || err) |
| { |
| return False(e); |
| } |
| } |
| return True(e); |
| } |
| else if (e->ident == Id::isSame) |
| { |
| /* Determine if two symbols are the same |
| */ |
| if (dim != 2) |
| return dimError(e, 2, dim); |
| |
| if (!TemplateInstance::semanticTiargs(e->loc, sc, e->args, 0)) |
| return new ErrorExp(); |
| |
| RootObject *o1 = (*e->args)[0]; |
| RootObject *o2 = (*e->args)[1]; |
| |
| // issue 12001, allow isSame, <BasicType>, <BasicType> |
| Type *t1 = isType(o1); |
| Type *t2 = isType(o2); |
| if (t1 && t2 && t1->equals(t2)) |
| return True(e); |
| |
| Dsymbol *s1 = getDsymbol(o1); |
| Dsymbol *s2 = getDsymbol(o2); |
| //printf("isSame: %s, %s\n", o1->toChars(), o2->toChars()); |
| if (!s1 && !s2) |
| { |
| Expression *ea1 = isExpression(o1); |
| Expression *ea2 = isExpression(o2); |
| if (ea1 && ea2) |
| { |
| if (ea1->equals(ea2)) |
| return True(e); |
| } |
| } |
| if (!s1 || !s2) |
| return False(e); |
| s1 = s1->toAlias(); |
| s2 = s2->toAlias(); |
| |
| if (s1->isFuncAliasDeclaration()) |
| s1 = ((FuncAliasDeclaration *)s1)->toAliasFunc(); |
| if (s2->isFuncAliasDeclaration()) |
| s2 = ((FuncAliasDeclaration *)s2)->toAliasFunc(); |
| |
| return (s1 == s2) ? True(e) : False(e); |
| } |
| else if (e->ident == Id::getUnitTests) |
| { |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| RootObject *o = (*e->args)[0]; |
| Dsymbol *s = getDsymbolWithoutExpCtx(o); |
| if (!s) |
| { |
| e->error("argument %s to __traits(getUnitTests) must be a module or aggregate", |
| o->toChars()); |
| return new ErrorExp(); |
| } |
| if (Import *imp = s->isImport()) // Bugzilla 10990 |
| s = imp->mod; |
| |
| ScopeDsymbol* sds = s->isScopeDsymbol(); |
| if (!sds) |
| { |
| e->error("argument %s to __traits(getUnitTests) must be a module or aggregate, not a %s", |
| s->toChars(), s->kind()); |
| return new ErrorExp(); |
| } |
| |
| Expressions *exps = new Expressions(); |
| if (global.params.useUnitTests) |
| { |
| // Should actually be a set |
| AA* uniqueUnitTests = NULL; |
| collectUnitTests(sds->members, uniqueUnitTests, exps); |
| } |
| TupleExp *te= new TupleExp(e->loc, exps); |
| return expressionSemantic(te, sc); |
| } |
| else if (e->ident == Id::getVirtualIndex) |
| { |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| RootObject *o = (*e->args)[0]; |
| Dsymbol *s = getDsymbolWithoutExpCtx(o); |
| |
| FuncDeclaration *fd = s ? s->isFuncDeclaration() : NULL; |
| if (!fd) |
| { |
| e->error("first argument to __traits(getVirtualIndex) must be a function"); |
| return new ErrorExp(); |
| } |
| |
| fd = fd->toAliasFunc(); // Neccessary to support multiple overloads. |
| return new IntegerExp(e->loc, fd->vtblIndex, Type::tptrdiff_t); |
| } |
| else if (e->ident == Id::getPointerBitmap) |
| { |
| return pointerBitmap(e); |
| } |
| else if (e->ident == Id::isZeroInit) |
| { |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| RootObject *o = (*e->args)[0]; |
| Type *t = isType(o); |
| if (!t) |
| { |
| e->error("type expected as second argument of __traits `%s` instead of `%s`", |
| e->ident->toChars(), o->toChars()); |
| return new ErrorExp(); |
| } |
| |
| Type *tb = t->baseElemOf(); |
| return tb->isZeroInit(e->loc) ? True(e) : False(e); |
| } |
| else if (e->ident == Id::getTargetInfo) |
| { |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| |
| Expression *ex = isExpression((*e->args)[0]); |
| StringExp *se = ex ? ex->ctfeInterpret()->toStringExp() : NULL; |
| if (!ex || !se || se->len == 0) |
| { |
| e->error("string expected as argument of __traits `%s` instead of `%s`", e->ident->toChars(), ex->toChars()); |
| return new ErrorExp(); |
| } |
| se = se->toUTF8(sc); |
| |
| Expression *r = target.getTargetInfo(se->toPtr(), e->loc); |
| if (!r) |
| { |
| e->error("`getTargetInfo` key `\"%s\"` not supported by this implementation", se->toPtr()); |
| return new ErrorExp(); |
| } |
| return expressionSemantic(r, sc); |
| } |
| else if (e->ident == Id::getLocation) |
| { |
| if (dim != 1) |
| return dimError(e, 1, dim); |
| RootObject *arg0 = (*e->args)[0]; |
| Dsymbol *s = getDsymbolWithoutExpCtx(arg0); |
| if (!s || !s->loc.filename) |
| { |
| e->error("can only get the location of a symbol, not `%s`", arg0->toChars()); |
| return new ErrorExp(); |
| } |
| |
| const FuncDeclaration *fd = s->isFuncDeclaration(); |
| if (fd && fd->overnext) |
| { |
| e->error("cannot get location of an overload set, " |
| "use `__traits(getOverloads, ..., \"%s\"%s)[N]` " |
| "to get the Nth overload", |
| arg0->toChars(), ""); |
| return new ErrorExp(); |
| } |
| |
| Expressions *exps = new Expressions(); |
| exps->setDim(3); |
| (*exps)[0] = new StringExp(e->loc, const_cast<char *>(s->loc.filename), strlen(s->loc.filename)); |
| (*exps)[1] = new IntegerExp(e->loc, s->loc.linnum, Type::tint32); |
| (*exps)[2] = new IntegerExp(e->loc, s->loc.charnum, Type::tint32); |
| TupleExp *tup = new TupleExp(e->loc, exps); |
| return expressionSemantic(tup, sc); |
| } |
| |
| if (const char *sub = (const char *)speller(e->ident->toChars(), &trait_search_fp, NULL, idchars)) |
| e->error("unrecognized trait `%s`, did you mean `%s`?", e->ident->toChars(), sub); |
| else |
| e->error("unrecognized trait `%s`", e->ident->toChars()); |
| return new ErrorExp(); |
| |
| e->error("wrong number of arguments %d", (int)dim); |
| return new ErrorExp(); |
| } |
