blob: bf18a2140fb188f0aa3d8489cdfd0e07c8d2022d [file] [log] [blame]
/**
* Performs the semantic2 stage, which deals with initializer expressions.
*
* Copyright: Copyright (C) 1999-2022 by The D Language Foundation, All Rights Reserved
* Authors: $(LINK2 https://www.digitalmars.com, Walter Bright)
* License: $(LINK2 https://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
* Source: $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/semantic2.d, _semantic2.d)
* Documentation: https://dlang.org/phobos/dmd_semantic2.html
* Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/semantic2.d
*/
module dmd.semantic2;
import core.stdc.stdio;
import core.stdc.string;
import dmd.aggregate;
import dmd.aliasthis;
import dmd.arraytypes;
import dmd.astcodegen;
import dmd.astenums;
import dmd.attrib;
import dmd.blockexit;
import dmd.clone;
import dmd.dcast;
import dmd.dclass;
import dmd.declaration;
import dmd.denum;
import dmd.dimport;
import dmd.dinterpret;
import dmd.dmodule;
import dmd.dscope;
import dmd.dstruct;
import dmd.dsymbol;
import dmd.dsymbolsem;
import dmd.dtemplate;
import dmd.dversion;
import dmd.errors;
import dmd.escape;
import dmd.expression;
import dmd.expressionsem;
import dmd.func;
import dmd.globals;
import dmd.id;
import dmd.identifier;
import dmd.init;
import dmd.initsem;
import dmd.hdrgen;
import dmd.mtype;
import dmd.nogc;
import dmd.nspace;
import dmd.objc;
import dmd.opover;
import dmd.parse;
import dmd.root.filename;
import dmd.common.outbuffer;
import dmd.root.rmem;
import dmd.root.rootobject;
import dmd.root.utf;
import dmd.sideeffect;
import dmd.statementsem;
import dmd.staticassert;
import dmd.tokens;
import dmd.statement;
import dmd.target;
import dmd.templateparamsem;
import dmd.typesem;
import dmd.visitor;
enum LOG = false;
/*************************************
* Does semantic analysis on initializers and members of aggregates.
*/
extern(C++) void semantic2(Dsymbol dsym, Scope* sc)
{
scope v = new Semantic2Visitor(sc);
dsym.accept(v);
}
private extern(C++) final class Semantic2Visitor : Visitor
{
alias visit = Visitor.visit;
Scope* sc;
this(Scope* sc)
{
this.sc = sc;
}
override void visit(Dsymbol) {}
override void visit(StaticAssert sa)
{
//printf("StaticAssert::semantic2() %s\n", sa.toChars());
auto sds = new ScopeDsymbol();
sc = sc.push(sds);
sc.tinst = null;
sc.minst = null;
import dmd.staticcond;
bool errors;
bool result = evalStaticCondition(sc, sa.exp, sa.exp, errors);
sc = sc.pop();
if (errors)
{
errorSupplemental(sa.loc, "while evaluating: `static assert(%s)`", sa.exp.toChars());
return;
}
else if (result)
return;
if (sa.msg)
{
sc = sc.startCTFE();
sa.msg = sa.msg.expressionSemantic(sc);
sa.msg = resolveProperties(sc, sa.msg);
sc = sc.endCTFE();
sa.msg = sa.msg.ctfeInterpret();
if (StringExp se = sa.msg.toStringExp())
{
// same with pragma(msg)
const slice = se.toUTF8(sc).peekString();
error(sa.loc, "static assert: \"%.*s\"", cast(int)slice.length, slice.ptr);
}
else
error(sa.loc, "static assert: %s", sa.msg.toChars());
}
else
error(sa.loc, "static assert: `%s` is false", sa.exp.toChars());
if (sc.tinst)
sc.tinst.printInstantiationTrace();
if (!global.gag)
fatal();
}
override void visit(TemplateInstance tempinst)
{
if (tempinst.semanticRun >= PASS.semantic2)
return;
tempinst.semanticRun = PASS.semantic2;
static if (LOG)
{
printf("+TemplateInstance.semantic2('%s')\n", tempinst.toChars());
scope(exit) printf("-TemplateInstance.semantic2('%s')\n", tempinst.toChars());
}
if (tempinst.errors || !tempinst.members)
return;
TemplateDeclaration tempdecl = tempinst.tempdecl.isTemplateDeclaration();
assert(tempdecl);
sc = tempdecl._scope;
assert(sc);
sc = sc.push(tempinst.argsym);
sc = sc.push(tempinst);
sc.tinst = tempinst;
sc.minst = tempinst.minst;
int needGagging = (tempinst.gagged && !global.gag);
uint olderrors = global.errors;
int oldGaggedErrors = -1; // dead-store to prevent spurious warning
if (needGagging)
oldGaggedErrors = global.startGagging();
for (size_t i = 0; i < tempinst.members.dim; i++)
{
Dsymbol s = (*tempinst.members)[i];
static if (LOG)
{
printf("\tmember '%s', kind = '%s'\n", s.toChars(), s.kind());
}
s.semantic2(sc);
if (tempinst.gagged && global.errors != olderrors)
break;
}
if (global.errors != olderrors)
{
if (!tempinst.errors)
{
if (!tempdecl.literal)
tempinst.error(tempinst.loc, "error instantiating");
if (tempinst.tinst)
tempinst.tinst.printInstantiationTrace();
}
tempinst.errors = true;
}
if (needGagging)
global.endGagging(oldGaggedErrors);
sc = sc.pop();
sc.pop();
}
override void visit(TemplateMixin tmix)
{
if (tmix.semanticRun >= PASS.semantic2)
return;
tmix.semanticRun = PASS.semantic2;
static if (LOG)
{
printf("+TemplateMixin.semantic2('%s')\n", tmix.toChars());
scope(exit) printf("-TemplateMixin.semantic2('%s')\n", tmix.toChars());
}
if (!tmix.members)
return;
assert(sc);
sc = sc.push(tmix.argsym);
sc = sc.push(tmix);
sc.tinst = tmix;
sc.minst = tmix.minst;
for (size_t i = 0; i < tmix.members.dim; i++)
{
Dsymbol s = (*tmix.members)[i];
static if (LOG)
{
printf("\tmember '%s', kind = '%s'\n", s.toChars(), s.kind());
}
s.semantic2(sc);
}
sc = sc.pop();
sc.pop();
}
override void visit(VarDeclaration vd)
{
if (vd.semanticRun < PASS.semanticdone && vd.inuse)
return;
//printf("VarDeclaration::semantic2('%s')\n", toChars());
if (vd.aliassym) // if it's a tuple
{
vd.aliassym.accept(this);
vd.semanticRun = PASS.semantic2done;
return;
}
UserAttributeDeclaration.checkGNUABITag(vd, vd._linkage);
if (vd._init && !vd.toParent().isFuncDeclaration())
{
vd.inuse++;
/* https://issues.dlang.org/show_bug.cgi?id=20280
*
* Template instances may import modules that have not
* finished semantic1.
*/
if (!vd.type)
vd.dsymbolSemantic(sc);
// https://issues.dlang.org/show_bug.cgi?id=14166
// https://issues.dlang.org/show_bug.cgi?id=20417
// Don't run CTFE for the temporary variables inside typeof or __traits(compiles)
vd._init = vd._init.initializerSemantic(sc, vd.type, sc.intypeof == 1 || sc.flags & SCOPE.compile ? INITnointerpret : INITinterpret);
vd.inuse--;
}
if (vd._init && vd.storage_class & STC.manifest)
{
/* Cannot initializer enums with CTFE classreferences and addresses of struct literals.
* Scan initializer looking for them. Issue error if found.
*/
if (ExpInitializer ei = vd._init.isExpInitializer())
{
static bool hasInvalidEnumInitializer(Expression e)
{
static bool arrayHasInvalidEnumInitializer(Expressions* elems)
{
foreach (e; *elems)
{
if (e && hasInvalidEnumInitializer(e))
return true;
}
return false;
}
if (e.op == EXP.classReference)
return true;
if (e.op == EXP.address && (cast(AddrExp)e).e1.op == EXP.structLiteral)
return true;
if (e.op == EXP.arrayLiteral)
return arrayHasInvalidEnumInitializer((cast(ArrayLiteralExp)e).elements);
if (e.op == EXP.structLiteral)
return arrayHasInvalidEnumInitializer((cast(StructLiteralExp)e).elements);
if (e.op == EXP.assocArrayLiteral)
{
AssocArrayLiteralExp ae = cast(AssocArrayLiteralExp)e;
return arrayHasInvalidEnumInitializer(ae.values) ||
arrayHasInvalidEnumInitializer(ae.keys);
}
return false;
}
if (hasInvalidEnumInitializer(ei.exp))
vd.error(": Unable to initialize enum with class or pointer to struct. Use static const variable instead.");
}
}
else if (vd._init && vd.isThreadlocal())
{
// Cannot initialize a thread-local class or pointer to struct variable with a literal
// that itself is a thread-local reference and would need dynamic initialization also.
if ((vd.type.ty == Tclass) && vd.type.isMutable() && !vd.type.isShared())
{
ExpInitializer ei = vd._init.isExpInitializer();
if (ei && ei.exp.op == EXP.classReference)
vd.error("is a thread-local class and cannot have a static initializer. Use `static this()` to initialize instead.");
}
else if (vd.type.ty == Tpointer && vd.type.nextOf().ty == Tstruct && vd.type.nextOf().isMutable() && !vd.type.nextOf().isShared())
{
ExpInitializer ei = vd._init.isExpInitializer();
if (ei && ei.exp.op == EXP.address && (cast(AddrExp)ei.exp).e1.op == EXP.structLiteral)
vd.error("is a thread-local pointer to struct and cannot have a static initializer. Use `static this()` to initialize instead.");
}
}
vd.semanticRun = PASS.semantic2done;
}
override void visit(Module mod)
{
//printf("Module::semantic2('%s'): parent = %p\n", toChars(), parent);
if (mod.semanticRun != PASS.semanticdone) // semantic() not completed yet - could be recursive call
return;
mod.semanticRun = PASS.semantic2;
// Note that modules get their own scope, from scratch.
// This is so regardless of where in the syntax a module
// gets imported, it is unaffected by context.
Scope* sc = Scope.createGlobal(mod); // create root scope
//printf("Module = %p\n", sc.scopesym);
if (mod.members)
{
// Pass 2 semantic routines: do initializers and function bodies
for (size_t i = 0; i < mod.members.dim; i++)
{
Dsymbol s = (*mod.members)[i];
s.semantic2(sc);
}
}
if (mod.userAttribDecl)
{
mod.userAttribDecl.semantic2(sc);
}
sc = sc.pop();
sc.pop();
mod.semanticRun = PASS.semantic2done;
//printf("-Module::semantic2('%s'): parent = %p\n", toChars(), parent);
}
override void visit(FuncDeclaration fd)
{
if (fd.semanticRun >= PASS.semantic2done)
return;
if (fd.semanticRun < PASS.semanticdone && !fd.errors)
{
/* https://issues.dlang.org/show_bug.cgi?id=21614
*
* Template instances may import modules that have not
* finished semantic1.
*/
fd.dsymbolSemantic(sc);
}
assert(fd.semanticRun <= PASS.semantic2);
fd.semanticRun = PASS.semantic2;
//printf("FuncDeclaration::semantic2 [%s] fd: %s type: %s\n", fd.loc.toChars(), fd.toChars(), fd.type ? fd.type.toChars() : "".ptr);
// Only check valid functions which have a body to avoid errors
// for multiple declarations, e.g.
// void foo();
// void foo();
if (fd.fbody && fd.overnext && !fd.errors)
{
// Always starts the lookup from 'this', because the conflicts with
// previous overloads are already reported.
alias f1 = fd;
auto tf1 = cast(TypeFunction) f1.type;
auto parent1 = f1.toParent2();
const linkage1 = f1.resolvedLinkage();
overloadApply(f1, (Dsymbol s)
{
auto f2 = s.isFuncDeclaration();
if (!f2 || f1 == f2 || f2.errors)
return 0;
// Don't have to check conflict between declaration and definition.
if (f2.fbody is null)
return 0;
// Functions with different manglings can never conflict
if (linkage1 != f2.resolvedLinkage())
return 0;
// Functions with different names never conflict
// (they can form overloads sets introduced by an alias)
if (f1.ident != f2.ident)
return 0;
// Functions with different parents never conflict
// (E.g. when aliasing a free function into a struct)
if (parent1 != f2.toParent2())
return 0;
/* Check for overload merging with base class member functions.
*
* class B { void foo() {} }
* class D : B {
* override void foo() {} // B.foo appears as f2
* alias foo = B.foo;
* }
*/
if (f1.overrides(f2))
return 0;
auto tf2 = cast(TypeFunction) f2.type;
// Overloading based on storage classes
if (tf1.mod != tf2.mod || ((f1.storage_class ^ f2.storage_class) & STC.static_))
return 0;
const sameAttr = tf1.attributesEqual(tf2);
const sameParams = tf1.parameterList == tf2.parameterList;
// Allow the hack to declare overloads with different parameters/STC's
// @@@DEPRECATED_2.104@@@
// Deprecated in 2020-08, make this an error in 2.104
if (parent1.isModule() &&
linkage1 != LINK.d && linkage1 != LINK.cpp &&
(!sameAttr || !sameParams)
)
{
f2.deprecation("cannot overload `extern(%s)` function at %s",
linkageToChars(f1._linkage),
f1.loc.toChars());
return 0;
}
// Different parameters don't conflict in extern(C++/D)
if (!sameParams)
return 0;
// Different attributes don't conflict in extern(D)
if (!sameAttr && linkage1 == LINK.d)
return 0;
error(f2.loc, "%s `%s%s` conflicts with previous declaration at %s",
f2.kind(),
f2.toPrettyChars(),
parametersTypeToChars(tf2.parameterList),
f1.loc.toChars());
f2.type = Type.terror;
f2.errors = true;
return 0;
});
}
if (!fd.type || fd.type.ty != Tfunction)
return;
TypeFunction f = cast(TypeFunction) fd.type;
UserAttributeDeclaration.checkGNUABITag(fd, fd._linkage);
//semantic for parameters' UDAs
foreach (i, param; f.parameterList)
{
if (param && param.userAttribDecl)
param.userAttribDecl.semantic2(sc);
}
}
override void visit(Import i)
{
//printf("Import::semantic2('%s')\n", toChars());
if (!i.mod)
return;
i.mod.semantic2(null);
if (i.mod.needmoduleinfo)
{
//printf("module5 %s because of %s\n", sc._module.toChars(), mod.toChars());
if (sc)
sc._module.needmoduleinfo = 1;
}
}
override void visit(Nspace ns)
{
if (ns.semanticRun >= PASS.semantic2)
return;
ns.semanticRun = PASS.semantic2;
static if (LOG)
{
printf("+Nspace::semantic2('%s')\n", ns.toChars());
scope(exit) printf("-Nspace::semantic2('%s')\n", ns.toChars());
}
UserAttributeDeclaration.checkGNUABITag(ns, LINK.cpp);
if (!ns.members)
return;
assert(sc);
sc = sc.push(ns);
sc.linkage = LINK.cpp;
foreach (s; *ns.members)
{
static if (LOG)
{
printf("\tmember '%s', kind = '%s'\n", s.toChars(), s.kind());
}
s.semantic2(sc);
}
sc.pop();
}
override void visit(AttribDeclaration ad)
{
Dsymbols* d = ad.include(sc);
if (!d)
return;
Scope* sc2 = ad.newScope(sc);
for (size_t i = 0; i < d.dim; i++)
{
Dsymbol s = (*d)[i];
s.semantic2(sc2);
}
if (sc2 != sc)
sc2.pop();
}
/**
* Run the DeprecatedDeclaration's semantic2 phase then its members.
*
* The message set via a `DeprecatedDeclaration` can be either of:
* - a string literal
* - an enum
* - a static immutable
* So we need to call ctfe to resolve it.
* Afterward forwards to the members' semantic2.
*/
override void visit(DeprecatedDeclaration dd)
{
getMessage(dd);
visit(cast(AttribDeclaration)dd);
}
override void visit(AlignDeclaration ad)
{
ad.getAlignment(sc);
visit(cast(AttribDeclaration)ad);
}
override void visit(CPPNamespaceDeclaration decl)
{
UserAttributeDeclaration.checkGNUABITag(decl, LINK.cpp);
visit(cast(AttribDeclaration)decl);
}
override void visit(UserAttributeDeclaration uad)
{
if (!uad.decl || !uad.atts || !uad.atts.dim || !uad._scope)
return visit(cast(AttribDeclaration)uad);
Expression* lastTag;
static void eval(Scope* sc, Expressions* exps, ref Expression* lastTag)
{
foreach (ref Expression e; *exps)
{
if (!e)
continue;
e = e.expressionSemantic(sc);
if (definitelyValueParameter(e))
e = e.ctfeInterpret();
if (e.op == EXP.tuple)
{
TupleExp te = cast(TupleExp)e;
eval(sc, te.exps, lastTag);
}
// Handles compiler-recognized `core.attribute.gnuAbiTag`
if (UserAttributeDeclaration.isGNUABITag(e))
doGNUABITagSemantic(e, lastTag);
}
}
uad._scope = null;
eval(sc, uad.atts, lastTag);
visit(cast(AttribDeclaration)uad);
}
override void visit(AggregateDeclaration ad)
{
//printf("AggregateDeclaration::semantic2(%s) type = %s, errors = %d\n", ad.toChars(), ad.type.toChars(), ad.errors);
if (!ad.members)
return;
if (ad._scope)
{
ad.error("has forward references");
return;
}
UserAttributeDeclaration.checkGNUABITag(
ad, ad.classKind == ClassKind.cpp ? LINK.cpp : LINK.d);
auto sc2 = ad.newScope(sc);
ad.determineSize(ad.loc);
for (size_t i = 0; i < ad.members.dim; i++)
{
Dsymbol s = (*ad.members)[i];
//printf("\t[%d] %s\n", i, s.toChars());
s.semantic2(sc2);
}
sc2.pop();
}
override void visit(ClassDeclaration cd)
{
/// Checks that the given class implements all methods of its interfaces.
static void checkInterfaceImplementations(ClassDeclaration cd)
{
foreach (base; cd.interfaces)
{
// first entry is ClassInfo reference
auto methods = base.sym.vtbl[base.sym.vtblOffset .. $];
foreach (m; methods)
{
auto ifd = m.isFuncDeclaration;
assert(ifd);
if (ifd.objc.isOptional)
continue;
auto type = ifd.type.toTypeFunction();
auto fd = cd.findFunc(ifd.ident, type);
if (fd && !fd.isAbstract)
{
//printf(" found\n");
// Check that calling conventions match
if (fd._linkage != ifd._linkage)
fd.error("linkage doesn't match interface function");
// Check that it is current
//printf("newinstance = %d fd.toParent() = %s ifd.toParent() = %s\n",
//newinstance, fd.toParent().toChars(), ifd.toParent().toChars());
if (fd.toParent() != cd && ifd.toParent() == base.sym)
cd.error("interface function `%s` is not implemented", ifd.toFullSignature());
}
else
{
//printf(" not found %p\n", fd);
// BUG: should mark this class as abstract?
if (!cd.isAbstract())
cd.error("interface function `%s` is not implemented", ifd.toFullSignature());
}
}
}
}
if (cd.semanticRun >= PASS.semantic2done)
return;
assert(cd.semanticRun <= PASS.semantic2);
cd.semanticRun = PASS.semantic2;
checkInterfaceImplementations(cd);
visit(cast(AggregateDeclaration) cd);
}
override void visit(InterfaceDeclaration cd)
{
visit(cast(AggregateDeclaration) cd);
}
override void visit(TupleDeclaration td)
{
td.foreachVar((s) { s.accept(this); });
}
}
/**
* Perform semantic analysis specific to the GNU ABI tags
*
* The GNU ABI tags are a feature introduced in C++11, specific to g++
* and the Itanium ABI.
* They are mandatory for C++ interfacing, simply because the templated struct
*`std::basic_string`, of which the ubiquitous `std::string` is a instantiation
* of, uses them.
*
* Params:
* e = Expression to perform semantic on
* See `Semantic2Visitor.visit(UserAttributeDeclaration)`
* lastTag = When `!is null`, we already saw an ABI tag.
* To simplify implementation and reflection code,
* only one ABI tag object is allowed per symbol
* (but it can have multiple tags as it's an array exp).
*/
private void doGNUABITagSemantic(ref Expression e, ref Expression* lastTag)
{
import dmd.dmangle;
// When `@gnuAbiTag` is used, the type will be the UDA, not the struct literal
if (e.op == EXP.type)
{
e.error("`@%s` at least one argument expected", Id.udaGNUAbiTag.toChars());
return;
}
// Definition is in `core.attributes`. If it's not a struct literal,
// it shouldn't have passed semantic, hence the `assert`.
auto sle = e.isStructLiteralExp();
if (sle is null)
{
assert(global.errors);
return;
}
// The definition of `gnuAttributes` only have 1 member, `string[] tags`
assert(sle.elements && sle.elements.length == 1);
// `gnuAbiTag`'s constructor is defined as `this(string[] tags...)`
auto ale = (*sle.elements)[0].isArrayLiteralExp();
if (ale is null)
{
e.error("`@%s` at least one argument expected", Id.udaGNUAbiTag.toChars());
return;
}
// Check that it's the only tag on the symbol
if (lastTag !is null)
{
const str1 = (*lastTag.isStructLiteralExp().elements)[0].toString();
const str2 = ale.toString();
e.error("only one `@%s` allowed per symbol", Id.udaGNUAbiTag.toChars());
e.errorSupplemental("instead of `@%s @%s`, use `@%s(%.*s, %.*s)`",
lastTag.toChars(), e.toChars(), Id.udaGNUAbiTag.toChars(),
// Avoid [ ... ]
cast(int)str1.length - 2, str1.ptr + 1,
cast(int)str2.length - 2, str2.ptr + 1);
return;
}
lastTag = &e;
// We already know we have a valid array literal of strings.
// Now checks that elements are valid.
foreach (idx, elem; *ale.elements)
{
const str = elem.toStringExp().peekString();
if (!str.length)
{
e.error("argument `%d` to `@%s` cannot be %s", cast(int)(idx + 1),
Id.udaGNUAbiTag.toChars(),
elem.isNullExp() ? "`null`".ptr : "empty".ptr);
continue;
}
foreach (c; str)
{
if (!c.isValidMangling())
{
e.error("`@%s` char `0x%02x` not allowed in mangling",
Id.udaGNUAbiTag.toChars(), c);
break;
}
}
// Valid element
}
// Since ABI tags need to be sorted, we sort them in place
// It might be surprising for users that inspects the UDAs,
// but it's a concession to practicality.
// Casts are unfortunately necessary as `implicitConvTo` is not
// `const` (and nor is `StringExp`, by extension).
static int predicate(const scope Expression* e1, const scope Expression* e2) nothrow
{
scope(failure) assert(0, "An exception was thrown");
return (cast(Expression*)e1).toStringExp().compare((cast(Expression*)e2).toStringExp());
}
ale.elements.sort!predicate;
}