| /** |
| * Semantic analysis for D types. |
| * |
| * Copyright: Copyright (C) 1999-2023 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/typesem.d, _typesem.d) |
| * Documentation: https://dlang.org/phobos/dmd_typesem.html |
| * Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/typesem.d |
| */ |
| |
| module dmd.typesem; |
| |
| import core.checkedint; |
| import core.stdc.string; |
| import core.stdc.stdio; |
| |
| import dmd.access; |
| import dmd.aggregate; |
| import dmd.aliasthis; |
| import dmd.arrayop; |
| import dmd.arraytypes; |
| import dmd.astcodegen; |
| import dmd.astenums; |
| import dmd.dcast; |
| import dmd.dclass; |
| import dmd.declaration; |
| import dmd.denum; |
| import dmd.dimport; |
| import dmd.dmangle; |
| import dmd.dmodule; |
| import dmd.dscope; |
| import dmd.dstruct; |
| import dmd.dsymbol; |
| import dmd.dsymbolsem; |
| import dmd.dtemplate; |
| import dmd.errors; |
| import dmd.errorsink; |
| import dmd.expression; |
| import dmd.expressionsem; |
| import dmd.func; |
| import dmd.globals; |
| import dmd.hdrgen; |
| import dmd.id; |
| import dmd.identifier; |
| import dmd.imphint; |
| import dmd.importc; |
| import dmd.init; |
| import dmd.initsem; |
| import dmd.location; |
| import dmd.visitor; |
| import dmd.mtype; |
| import dmd.objc; |
| import dmd.opover; |
| import dmd.parse; |
| import dmd.root.complex; |
| import dmd.root.ctfloat; |
| import dmd.root.rmem; |
| import dmd.common.outbuffer; |
| import dmd.root.rootobject; |
| import dmd.root.string; |
| import dmd.root.stringtable; |
| import dmd.safe; |
| import dmd.semantic3; |
| import dmd.sideeffect; |
| import dmd.target; |
| import dmd.tokens; |
| |
| /************************************* |
| * Resolve a tuple index, `s[oindex]`, by figuring out what `s[oindex]` represents. |
| * Setting one of pe/pt/ps. |
| * Params: |
| * loc = location for error messages |
| * sc = context |
| * s = symbol being indexed - could be a tuple, could be an expression |
| * pe = set if s[oindex] is an Expression, otherwise null |
| * pt = set if s[oindex] is a Type, otherwise null |
| * ps = set if s[oindex] is a Dsymbol, otherwise null |
| * oindex = index into s |
| */ |
| private void resolveTupleIndex(const ref Loc loc, Scope* sc, Dsymbol s, out Expression pe, out Type pt, out Dsymbol ps, RootObject oindex) |
| { |
| auto tup = s.isTupleDeclaration(); |
| |
| auto eindex = isExpression(oindex); |
| auto tindex = isType(oindex); |
| auto sindex = isDsymbol(oindex); |
| |
| if (!tup) |
| { |
| // It's really an index expression |
| if (tindex) |
| eindex = new TypeExp(loc, tindex); |
| else if (sindex) |
| eindex = symbolToExp(sindex, loc, sc, false); |
| Expression e = new IndexExp(loc, symbolToExp(s, loc, sc, false), eindex); |
| e = e.expressionSemantic(sc); |
| resolveExp(e, pt, pe, ps); |
| return; |
| } |
| |
| // Convert oindex to Expression, then try to resolve to constant. |
| if (tindex) |
| tindex.resolve(loc, sc, eindex, tindex, sindex); |
| if (sindex) |
| eindex = symbolToExp(sindex, loc, sc, false); |
| if (!eindex) |
| { |
| .error(loc, "index `%s` is not an expression", oindex.toChars()); |
| pt = Type.terror; |
| return; |
| } |
| |
| eindex = semanticLength(sc, tup, eindex); |
| eindex = eindex.ctfeInterpret(); |
| if (eindex.op == EXP.error) |
| { |
| pt = Type.terror; |
| return; |
| } |
| const(uinteger_t) d = eindex.toUInteger(); |
| if (d >= tup.objects.length) |
| { |
| .error(loc, "tuple index `%llu` out of bounds `[0 .. %llu]`", d, cast(ulong)tup.objects.length); |
| pt = Type.terror; |
| return; |
| } |
| |
| RootObject o = (*tup.objects)[cast(size_t)d]; |
| ps = isDsymbol(o); |
| if (auto t = isType(o)) |
| pt = t.typeSemantic(loc, sc); |
| if (auto e = isExpression(o)) |
| resolveExp(e, pt, pe, ps); |
| } |
| |
| /************************************* |
| * Takes an array of Identifiers and figures out if |
| * it represents a Type, Expression, or Dsymbol. |
| * Params: |
| * mt = array of identifiers |
| * loc = location for error messages |
| * sc = context |
| * s = symbol to start search at |
| * scopesym = unused |
| * pe = set if expression otherwise null |
| * pt = set if type otherwise null |
| * ps = set if symbol otherwise null |
| * typeid = set if in TypeidExpression https://dlang.org/spec/expression.html#TypeidExpression |
| */ |
| private void resolveHelper(TypeQualified mt, const ref Loc loc, Scope* sc, Dsymbol s, Dsymbol scopesym, |
| out Expression pe, out Type pt, out Dsymbol ps, bool intypeid = false) |
| { |
| version (none) |
| { |
| printf("TypeQualified::resolveHelper(sc = %p, idents = '%s')\n", sc, mt.toChars()); |
| if (scopesym) |
| printf("\tscopesym = '%s'\n", scopesym.toChars()); |
| } |
| |
| if (!s) |
| { |
| /* Look for what user might have intended |
| */ |
| const p = mt.mutableOf().unSharedOf().toChars(); |
| auto id = Identifier.idPool(p, cast(uint)strlen(p)); |
| if (const n = importHint(id.toString())) |
| error(loc, "`%s` is not defined, perhaps `import %.*s;` ?", p, cast(int)n.length, n.ptr); |
| else if (auto s2 = sc.search_correct(id)) |
| error(loc, "undefined identifier `%s`, did you mean %s `%s`?", p, s2.kind(), s2.toChars()); |
| else if (const q = Scope.search_correct_C(id)) |
| error(loc, "undefined identifier `%s`, did you mean `%s`?", p, q); |
| else if ((id == Id.This && sc.getStructClassScope()) || |
| (id == Id._super && sc.getClassScope())) |
| error(loc, "undefined identifier `%s`, did you mean `typeof(%s)`?", p, p); |
| else |
| error(loc, "undefined identifier `%s`", p); |
| |
| pt = Type.terror; |
| return; |
| } |
| |
| //printf("\t1: s = '%s' %p, kind = '%s'\n",s.toChars(), s, s.kind()); |
| Declaration d = s.isDeclaration(); |
| if (d && (d.storage_class & STC.templateparameter)) |
| s = s.toAlias(); |
| else |
| { |
| // check for deprecated or disabled aliases |
| // functions are checked after overloading |
| // templates are checked after matching constraints |
| if (!s.isFuncDeclaration() && !s.isTemplateDeclaration()) |
| s.checkDeprecated(loc, sc); |
| if (d) |
| d.checkDisabled(loc, sc, true); |
| } |
| s = s.toAlias(); |
| //printf("\t2: s = '%s' %p, kind = '%s'\n",s.toChars(), s, s.kind()); |
| for (size_t i = 0; i < mt.idents.length; i++) |
| { |
| RootObject id = mt.idents[i]; |
| switch (id.dyncast()) with (DYNCAST) |
| { |
| case expression: |
| case type: |
| Type tx; |
| Expression ex; |
| Dsymbol sx; |
| resolveTupleIndex(loc, sc, s, ex, tx, sx, id); |
| if (sx) |
| { |
| s = sx.toAlias(); |
| continue; |
| } |
| if (tx) |
| ex = new TypeExp(loc, tx); |
| assert(ex); |
| |
| ex = typeToExpressionHelper(mt, ex, i + 1); |
| ex = ex.expressionSemantic(sc); |
| resolveExp(ex, pt, pe, ps); |
| return; |
| default: |
| break; |
| } |
| |
| Type t = s.getType(); // type symbol, type alias, or type tuple? |
| uint errorsave = global.errors; |
| int flags = t is null ? SearchLocalsOnly : IgnorePrivateImports; |
| |
| Dsymbol sm = s.searchX(loc, sc, id, flags); |
| if (sm) |
| { |
| if (!(sc.flags & SCOPE.ignoresymbolvisibility) && !symbolIsVisible(sc, sm)) |
| { |
| .error(loc, "`%s` is not visible from module `%s`", sm.toPrettyChars(), sc._module.toChars()); |
| sm = null; |
| } |
| // Same check as in dotIdSemanticProp(DotIdExp) |
| else if (sm.isPackage() && checkAccess(sc, sm.isPackage())) |
| { |
| // @@@DEPRECATED_2.106@@@ |
| // Should be an error in 2.106. Just remove the deprecation call |
| // and uncomment the null assignment |
| deprecation(loc, "%s %s is not accessible here, perhaps add 'static import %s;'", sm.kind(), sm.toPrettyChars(), sm.toPrettyChars()); |
| //sm = null; |
| } |
| } |
| if (global.errors != errorsave) |
| { |
| pt = Type.terror; |
| return; |
| } |
| |
| void helper3() |
| { |
| Expression e; |
| VarDeclaration v = s.isVarDeclaration(); |
| FuncDeclaration f = s.isFuncDeclaration(); |
| if (intypeid || !v && !f) |
| e = symbolToExp(s, loc, sc, true); |
| else |
| e = new VarExp(loc, s.isDeclaration(), true); |
| |
| e = typeToExpressionHelper(mt, e, i); |
| e = e.expressionSemantic(sc); |
| resolveExp(e, pt, pe, ps); |
| } |
| |
| //printf("\t3: s = %p %s %s, sm = %p\n", s, s.kind(), s.toChars(), sm); |
| if (intypeid && !t && sm && sm.needThis()) |
| return helper3(); |
| |
| if (VarDeclaration v = s.isVarDeclaration()) |
| { |
| // https://issues.dlang.org/show_bug.cgi?id=19913 |
| // v.type would be null if it is a forward referenced member. |
| if (v.type is null) |
| v.dsymbolSemantic(sc); |
| if (v.storage_class & (STC.const_ | STC.immutable_ | STC.manifest) || |
| v.type.isConst() || v.type.isImmutable()) |
| { |
| // https://issues.dlang.org/show_bug.cgi?id=13087 |
| // this.field is not constant always |
| if (!v.isThisDeclaration()) |
| return helper3(); |
| } |
| } |
| |
| if (!sm) |
| return helper3(); |
| |
| s = sm.toAlias(); |
| } |
| |
| if (auto em = s.isEnumMember()) |
| { |
| // It's not a type, it's an expression |
| pe = em.getVarExp(loc, sc); |
| return; |
| } |
| if (auto v = s.isVarDeclaration()) |
| { |
| /* This is mostly same with DsymbolExp::semantic(), but we cannot use it |
| * because some variables used in type context need to prevent lowering |
| * to a literal or contextful expression. For example: |
| * |
| * enum a = 1; alias b = a; |
| * template X(alias e){ alias v = e; } alias x = X!(1); |
| * struct S { int v; alias w = v; } |
| * // TypeIdentifier 'a', 'e', and 'v' should be EXP.variable, |
| * // because getDsymbol() need to work in AliasDeclaration::semantic(). |
| */ |
| if (!v.type || |
| !v.type.deco && v.inuse) |
| { |
| if (v.inuse) // https://issues.dlang.org/show_bug.cgi?id=9494 |
| error(loc, "circular reference to %s `%s`", v.kind(), v.toPrettyChars()); |
| else |
| error(loc, "forward reference to %s `%s`", v.kind(), v.toPrettyChars()); |
| pt = Type.terror; |
| return; |
| } |
| if (v.type.ty == Terror) |
| pt = Type.terror; |
| else |
| pe = new VarExp(loc, v); |
| return; |
| } |
| if (auto fld = s.isFuncLiteralDeclaration()) |
| { |
| //printf("'%s' is a function literal\n", fld.toChars()); |
| auto e = new FuncExp(loc, fld); |
| pe = e.expressionSemantic(sc); |
| return; |
| } |
| version (none) |
| { |
| if (FuncDeclaration fd = s.isFuncDeclaration()) |
| { |
| pe = new DsymbolExp(loc, fd); |
| return; |
| } |
| } |
| |
| Type t; |
| while (1) |
| { |
| t = s.getType(); |
| if (t) |
| break; |
| ps = s; |
| return; |
| } |
| |
| if (auto ti = t.isTypeInstance()) |
| if (ti != mt && !ti.deco) |
| { |
| if (!ti.tempinst.errors) |
| error(loc, "forward reference to `%s`", ti.toChars()); |
| pt = Type.terror; |
| return; |
| } |
| |
| if (t.ty == Ttuple) |
| pt = t; |
| else |
| pt = t.merge(); |
| } |
| |
| /****************************************** |
| * We've mistakenly parsed `t` as a type. |
| * Redo `t` as an Expression only if there are no type modifiers. |
| * Params: |
| * t = mistaken type |
| * Returns: |
| * t redone as Expression, null if cannot |
| */ |
| Expression typeToExpression(Type t) |
| { |
| static Expression visitSArray(TypeSArray t) |
| { |
| if (auto e = t.next.typeToExpression()) |
| return new ArrayExp(t.dim.loc, e, t.dim); |
| return null; |
| } |
| |
| static Expression visitAArray(TypeAArray t) |
| { |
| if (auto e = t.next.typeToExpression()) |
| { |
| if (auto ei = t.index.typeToExpression()) |
| return new ArrayExp(t.loc, e, ei); |
| } |
| return null; |
| } |
| |
| static Expression visitIdentifier(TypeIdentifier t) |
| { |
| return typeToExpressionHelper(t, new IdentifierExp(t.loc, t.ident)); |
| } |
| |
| static Expression visitInstance(TypeInstance t) |
| { |
| return typeToExpressionHelper(t, new ScopeExp(t.loc, t.tempinst)); |
| } |
| |
| // easy way to enable 'auto v = new int[mixin("exp")];' in 2.088+ |
| static Expression visitMixin(TypeMixin t) |
| { |
| return new TypeExp(t.loc, t); |
| } |
| |
| if (t.mod) |
| return null; |
| switch (t.ty) |
| { |
| case Tsarray: return visitSArray(t.isTypeSArray()); |
| case Taarray: return visitAArray(t.isTypeAArray()); |
| case Tident: return visitIdentifier(t.isTypeIdentifier()); |
| case Tinstance: return visitInstance(t.isTypeInstance()); |
| case Tmixin: return visitMixin(t.isTypeMixin()); |
| default: return null; |
| } |
| } |
| |
| /****************************************** |
| * Perform semantic analysis on a type. |
| * Params: |
| * type = Type AST node |
| * loc = the location of the type |
| * sc = context |
| * Returns: |
| * `Type` with completed semantic analysis, `Terror` if errors |
| * were encountered |
| */ |
| extern(C++) Type typeSemantic(Type type, const ref Loc loc, Scope* sc) |
| { |
| static Type error() |
| { |
| return Type.terror; |
| } |
| |
| Type visitType(Type t) |
| { |
| // @@@DEPRECATED_2.110@@@ |
| // Use of `cent` and `ucent` has always been an error. |
| // Starting from 2.100, recommend core.int128 as a replace for the |
| // lack of compiler support. |
| if (t.ty == Tint128 || t.ty == Tuns128) |
| { |
| .error(loc, "`cent` and `ucent` types are obsolete, use `core.int128.Cent` instead"); |
| return error(); |
| } |
| |
| return t.merge(); |
| } |
| |
| Type visitVector(TypeVector mtype) |
| { |
| const errors = global.errors; |
| mtype.basetype = mtype.basetype.typeSemantic(loc, sc); |
| if (errors != global.errors) |
| return error(); |
| mtype.basetype = mtype.basetype.toBasetype().mutableOf(); |
| if (mtype.basetype.ty != Tsarray) |
| { |
| .error(loc, "T in __vector(T) must be a static array, not `%s`", mtype.basetype.toChars()); |
| return error(); |
| } |
| TypeSArray t = mtype.basetype.isTypeSArray(); |
| const sz = cast(int)t.size(loc); |
| final switch (target.isVectorTypeSupported(sz, t.nextOf())) |
| { |
| case 0: |
| // valid |
| break; |
| |
| case 1: |
| // no support at all |
| .error(loc, "SIMD vector types not supported on this platform"); |
| return error(); |
| |
| case 2: |
| // invalid base type |
| .error(loc, "vector type `%s` is not supported on this platform", mtype.toChars()); |
| return error(); |
| |
| case 3: |
| // invalid size |
| .error(loc, "%d byte vector type `%s` is not supported on this platform", sz, mtype.toChars()); |
| return error(); |
| } |
| return merge(mtype); |
| } |
| |
| Type visitSArray(TypeSArray mtype) |
| { |
| //printf("TypeSArray::semantic() %s\n", toChars()); |
| Type t; |
| Expression e; |
| Dsymbol s; |
| mtype.next.resolve(loc, sc, e, t, s); |
| |
| if (auto tup = s ? s.isTupleDeclaration() : null) |
| { |
| mtype.dim = semanticLength(sc, tup, mtype.dim); |
| mtype.dim = mtype.dim.ctfeInterpret(); |
| if (mtype.dim.op == EXP.error) |
| return error(); |
| |
| uinteger_t d = mtype.dim.toUInteger(); |
| if (d >= tup.objects.length) |
| { |
| .error(loc, "tuple index `%llu` out of bounds `[0 .. %llu]`", cast(ulong)d, cast(ulong)tup.objects.length); |
| return error(); |
| } |
| |
| RootObject o = (*tup.objects)[cast(size_t)d]; |
| if (o.dyncast() != DYNCAST.type) |
| { |
| .error(loc, "`%s` is not a type", mtype.toChars()); |
| return error(); |
| } |
| return (cast(Type)o).addMod(mtype.mod); |
| } |
| |
| if (t && t.ty == Terror) |
| return error(); |
| |
| Type tn = mtype.next.typeSemantic(loc, sc); |
| if (tn.ty == Terror) |
| return error(); |
| |
| Type tbn = tn.toBasetype(); |
| if (mtype.dim) |
| { |
| auto errors = global.errors; |
| mtype.dim = semanticLength(sc, tbn, mtype.dim); |
| mtype.dim = mtype.dim.implicitCastTo(sc, Type.tsize_t); |
| if (errors != global.errors) |
| return error(); |
| |
| mtype.dim = mtype.dim.optimize(WANTvalue); |
| mtype.dim = mtype.dim.ctfeInterpret(); |
| if (mtype.dim.op == EXP.error) |
| return error(); |
| |
| errors = global.errors; |
| dinteger_t d1 = mtype.dim.toInteger(); |
| if (errors != global.errors) |
| return error(); |
| |
| mtype.dim = mtype.dim.implicitCastTo(sc, Type.tsize_t); |
| mtype.dim = mtype.dim.optimize(WANTvalue); |
| if (mtype.dim.op == EXP.error) |
| return error(); |
| |
| errors = global.errors; |
| dinteger_t d2 = mtype.dim.toInteger(); |
| if (errors != global.errors) |
| return error(); |
| |
| if (mtype.dim.op == EXP.error) |
| return error(); |
| |
| Type overflowError() |
| { |
| .error(loc, "`%s` size %llu * %llu exceeds 0x%llx size limit for static array", |
| mtype.toChars(), cast(ulong)tbn.size(loc), cast(ulong)d1, target.maxStaticDataSize); |
| return error(); |
| } |
| |
| if (d1 != d2) |
| return overflowError(); |
| |
| Type tbx = tbn.baseElemOf(); |
| if (tbx.ty == Tstruct && !tbx.isTypeStruct().sym.members || |
| tbx.ty == Tenum && !tbx.isTypeEnum().sym.members) |
| { |
| /* To avoid meaningless error message, skip the total size limit check |
| * when the bottom of element type is opaque. |
| */ |
| } |
| else if (tbn.isTypeBasic() || |
| tbn.ty == Tpointer || |
| tbn.ty == Tarray || |
| tbn.ty == Tsarray || |
| tbn.ty == Taarray || |
| (tbn.ty == Tstruct && tbn.isTypeStruct().sym.sizeok == Sizeok.done) || |
| tbn.ty == Tclass) |
| { |
| /* Only do this for types that don't need to have semantic() |
| * run on them for the size, since they may be forward referenced. |
| */ |
| bool overflow = false; |
| if (mulu(tbn.size(loc), d2, overflow) > target.maxStaticDataSize || overflow) |
| return overflowError(); |
| } |
| } |
| switch (tbn.ty) |
| { |
| case Ttuple: |
| { |
| // Index the tuple to get the type |
| assert(mtype.dim); |
| TypeTuple tt = tbn.isTypeTuple(); |
| uinteger_t d = mtype.dim.toUInteger(); |
| if (d >= tt.arguments.length) |
| { |
| .error(loc, "tuple index `%llu` out of bounds `[0 .. %llu]`", cast(ulong)d, cast(ulong)tt.arguments.length); |
| return error(); |
| } |
| Type telem = (*tt.arguments)[cast(size_t)d].type; |
| return telem.addMod(mtype.mod); |
| } |
| |
| case Tfunction: |
| case Tnone: |
| .error(loc, "cannot have array of `%s`", tbn.toChars()); |
| return error(); |
| |
| default: |
| break; |
| } |
| if (tbn.isscope()) |
| { |
| .error(loc, "cannot have array of scope `%s`", tbn.toChars()); |
| return error(); |
| } |
| |
| /* Ensure things like const(immutable(T)[3]) become immutable(T[3]) |
| * and const(T)[3] become const(T[3]) |
| */ |
| mtype.next = tn; |
| mtype.transitive(); |
| return mtype.addMod(tn.mod).merge(); |
| } |
| |
| Type visitDArray(TypeDArray mtype) |
| { |
| Type tn = mtype.next.typeSemantic(loc, sc); |
| Type tbn = tn.toBasetype(); |
| switch (tbn.ty) |
| { |
| case Ttuple: |
| return tbn; |
| |
| case Tfunction: |
| case Tnone: |
| .error(loc, "cannot have array of `%s`", tbn.toChars()); |
| return error(); |
| |
| case Terror: |
| return error(); |
| |
| default: |
| break; |
| } |
| if (tn.isscope()) |
| { |
| .error(loc, "cannot have array of scope `%s`", tn.toChars()); |
| return error(); |
| } |
| mtype.next = tn; |
| mtype.transitive(); |
| return merge(mtype); |
| } |
| |
| Type visitAArray(TypeAArray mtype) |
| { |
| //printf("TypeAArray::semantic() %s index.ty = %d\n", mtype.toChars(), mtype.index.ty); |
| if (mtype.deco) |
| { |
| return mtype; |
| } |
| |
| mtype.loc = loc; |
| if (sc) |
| sc.setNoFree(); |
| |
| // Deal with the case where we thought the index was a type, but |
| // in reality it was an expression. |
| if (mtype.index.ty == Tident || mtype.index.ty == Tinstance || mtype.index.ty == Tsarray || mtype.index.ty == Ttypeof || mtype.index.ty == Treturn || mtype.index.ty == Tmixin) |
| { |
| Expression e; |
| Type t; |
| Dsymbol s; |
| mtype.index.resolve(loc, sc, e, t, s); |
| |
| // https://issues.dlang.org/show_bug.cgi?id=15478 |
| if (s) |
| e = symbolToExp(s, loc, sc, false); |
| |
| if (e) |
| { |
| // It was an expression - |
| // Rewrite as a static array |
| auto tsa = new TypeSArray(mtype.next, e); |
| return tsa.typeSemantic(loc, sc); |
| } |
| else if (t) |
| mtype.index = t.typeSemantic(loc, sc); |
| else |
| { |
| .error(loc, "index is not a type or an expression"); |
| return error(); |
| } |
| } |
| else |
| mtype.index = mtype.index.typeSemantic(loc, sc); |
| mtype.index = mtype.index.merge2(); |
| |
| if (mtype.index.nextOf() && !mtype.index.nextOf().isImmutable()) |
| { |
| mtype.index = mtype.index.constOf().mutableOf(); |
| version (none) |
| { |
| printf("index is %p %s\n", mtype.index, mtype.index.toChars()); |
| mtype.index.check(); |
| printf("index.mod = x%x\n", mtype.index.mod); |
| printf("index.ito = x%p\n", mtype.index.getMcache().ito); |
| if (mtype.index.getMcache().ito) |
| { |
| printf("index.ito.mod = x%x\n", mtype.index.getMcache().ito.mod); |
| printf("index.ito.ito = x%p\n", mtype.index.getMcache().ito.getMcache().ito); |
| } |
| } |
| } |
| |
| switch (mtype.index.toBasetype().ty) |
| { |
| case Tfunction: |
| case Tvoid: |
| case Tnone: |
| case Ttuple: |
| .error(loc, "cannot have associative array key of `%s`", mtype.index.toBasetype().toChars()); |
| goto case Terror; |
| case Terror: |
| return error(); |
| |
| default: |
| break; |
| } |
| Type tbase = mtype.index.baseElemOf(); |
| while (tbase.ty == Tarray) |
| tbase = tbase.nextOf().baseElemOf(); |
| if (auto ts = tbase.isTypeStruct()) |
| { |
| /* AA's need typeid(index).equals() and getHash(). Issue error if not correctly set up. |
| */ |
| StructDeclaration sd = ts.sym; |
| if (sd.semanticRun < PASS.semanticdone) |
| sd.dsymbolSemantic(null); |
| |
| // duplicate a part of StructDeclaration::semanticTypeInfoMembers |
| //printf("AA = %s, key: xeq = %p, xerreq = %p xhash = %p\n", toChars(), sd.xeq, sd.xerreq, sd.xhash); |
| |
| if (sd.xeq && sd.xeq.isGenerated() && sd.xeq._scope && sd.xeq.semanticRun < PASS.semantic3done) |
| { |
| uint errors = global.startGagging(); |
| sd.xeq.semantic3(sd.xeq._scope); |
| if (global.endGagging(errors)) |
| sd.xeq = sd.xerreq; |
| } |
| |
| |
| //printf("AA = %s, key: xeq = %p, xhash = %p\n", toChars(), sd.xeq, sd.xhash); |
| const(char)* s = (mtype.index.toBasetype().ty != Tstruct) ? "bottom of " : ""; |
| if (!sd.xeq) |
| { |
| // If sd.xhash != NULL: |
| // sd or its fields have user-defined toHash. |
| // AA assumes that its result is consistent with bitwise equality. |
| // else: |
| // bitwise equality & hashing |
| } |
| else if (sd.xeq == sd.xerreq) |
| { |
| if (search_function(sd, Id.eq)) |
| { |
| .error(loc, "%sAA key type `%s` does not have `bool opEquals(ref const %s) const`", s, sd.toChars(), sd.toChars()); |
| } |
| else |
| { |
| .error(loc, "%sAA key type `%s` does not support const equality", s, sd.toChars()); |
| } |
| return error(); |
| } |
| else if (!sd.xhash) |
| { |
| if (search_function(sd, Id.eq)) |
| { |
| .error(loc, "%sAA key type `%s` should have `extern (D) size_t toHash() const nothrow @safe` if `opEquals` defined", s, sd.toChars()); |
| } |
| else |
| { |
| .error(loc, "%sAA key type `%s` supports const equality but doesn't support const hashing", s, sd.toChars()); |
| } |
| return error(); |
| } |
| else |
| { |
| // defined equality & hashing |
| assert(sd.xeq && sd.xhash); |
| |
| /* xeq and xhash may be implicitly defined by compiler. For example: |
| * struct S { int[] arr; } |
| * With 'arr' field equality and hashing, compiler will implicitly |
| * generate functions for xopEquals and xtoHash in TypeInfo_Struct. |
| */ |
| } |
| } |
| else if (tbase.ty == Tclass && !tbase.isTypeClass().sym.isInterfaceDeclaration()) |
| { |
| ClassDeclaration cd = tbase.isTypeClass().sym; |
| if (cd.semanticRun < PASS.semanticdone) |
| cd.dsymbolSemantic(null); |
| |
| if (!ClassDeclaration.object) |
| { |
| .error(Loc.initial, "missing or corrupt object.d"); |
| fatal(); |
| } |
| |
| __gshared FuncDeclaration feq = null; |
| __gshared FuncDeclaration fcmp = null; |
| __gshared FuncDeclaration fhash = null; |
| if (!feq) |
| feq = search_function(ClassDeclaration.object, Id.eq).isFuncDeclaration(); |
| if (!fcmp) |
| fcmp = search_function(ClassDeclaration.object, Id.cmp).isFuncDeclaration(); |
| if (!fhash) |
| fhash = search_function(ClassDeclaration.object, Id.tohash).isFuncDeclaration(); |
| assert(fcmp && feq && fhash); |
| |
| if (feq.vtblIndex < cd.vtbl.length && cd.vtbl[feq.vtblIndex] == feq) |
| { |
| version (all) |
| { |
| if (fcmp.vtblIndex < cd.vtbl.length && cd.vtbl[fcmp.vtblIndex] != fcmp) |
| { |
| const(char)* s = (mtype.index.toBasetype().ty != Tclass) ? "bottom of " : ""; |
| .error(loc, "%sAA key type `%s` now requires equality rather than comparison", s, cd.toChars()); |
| errorSupplemental(loc, "Please override `Object.opEquals` and `Object.toHash`."); |
| } |
| } |
| } |
| } |
| mtype.next = mtype.next.typeSemantic(loc, sc).merge2(); |
| mtype.transitive(); |
| |
| switch (mtype.next.toBasetype().ty) |
| { |
| case Tfunction: |
| case Tvoid: |
| case Tnone: |
| case Ttuple: |
| .error(loc, "cannot have associative array of `%s`", mtype.next.toChars()); |
| goto case Terror; |
| case Terror: |
| return error(); |
| default: |
| break; |
| } |
| if (mtype.next.isscope()) |
| { |
| .error(loc, "cannot have array of scope `%s`", mtype.next.toChars()); |
| return error(); |
| } |
| return merge(mtype); |
| } |
| |
| Type visitPointer(TypePointer mtype) |
| { |
| //printf("TypePointer::semantic() %s\n", toChars()); |
| if (mtype.deco) |
| { |
| return mtype; |
| } |
| Type n = mtype.next.typeSemantic(loc, sc); |
| switch (n.toBasetype().ty) |
| { |
| case Ttuple: |
| .error(loc, "cannot have pointer to `%s`", n.toChars()); |
| goto case Terror; |
| case Terror: |
| return error(); |
| default: |
| break; |
| } |
| if (n != mtype.next) |
| { |
| mtype.deco = null; |
| } |
| mtype.next = n; |
| if (mtype.next.ty != Tfunction) |
| { |
| mtype.transitive(); |
| return merge(mtype); |
| } |
| version (none) |
| { |
| return merge(mtype); |
| } |
| else |
| { |
| mtype.deco = merge(mtype).deco; |
| /* Don't return merge(), because arg identifiers and default args |
| * can be different |
| * even though the types match |
| */ |
| return mtype; |
| } |
| } |
| |
| Type visitReference(TypeReference mtype) |
| { |
| //printf("TypeReference::semantic()\n"); |
| Type n = mtype.next.typeSemantic(loc, sc); |
| if (n != mtype.next) |
| mtype.deco = null; |
| mtype.next = n; |
| mtype.transitive(); |
| return merge(mtype); |
| } |
| |
| Type visitFunction(TypeFunction mtype) |
| { |
| if (mtype.deco) // if semantic() already run |
| { |
| //printf("already done\n"); |
| return mtype; |
| } |
| //printf("TypeFunction::semantic() this = %p\n", mtype); |
| //printf("TypeFunction::semantic() %s, sc.stc = %llx\n", mtype.toChars(), sc.stc); |
| |
| bool errors = false; |
| |
| if (mtype.inuse > global.recursionLimit) |
| { |
| mtype.inuse = 0; |
| .error(loc, "recursive type"); |
| return error(); |
| } |
| |
| /* Copy in order to not mess up original. |
| * This can produce redundant copies if inferring return type, |
| * as semantic() will get called again on this. |
| */ |
| TypeFunction tf = mtype.copy().toTypeFunction(); |
| if (mtype.parameterList.parameters) |
| { |
| tf.parameterList.parameters = mtype.parameterList.parameters.copy(); |
| for (size_t i = 0; i < mtype.parameterList.parameters.length; i++) |
| { |
| Parameter p = cast(Parameter)mem.xmalloc(__traits(classInstanceSize, Parameter)); |
| memcpy(cast(void*)p, cast(void*)(*mtype.parameterList.parameters)[i], __traits(classInstanceSize, Parameter)); |
| (*tf.parameterList.parameters)[i] = p; |
| } |
| } |
| |
| if (sc.stc & STC.pure_) |
| tf.purity = PURE.fwdref; |
| if (sc.stc & STC.nothrow_) |
| tf.isnothrow = true; |
| if (sc.stc & STC.nogc) |
| tf.isnogc = true; |
| if (sc.stc & STC.ref_) |
| tf.isref = true; |
| if (sc.stc & STC.return_) |
| tf.isreturn = true; |
| if (sc.stc & STC.returnScope) |
| tf.isreturnscope = true; |
| if (sc.stc & STC.returninferred) |
| tf.isreturninferred = true; |
| if (sc.stc & STC.scope_) |
| tf.isScopeQual = true; |
| if (sc.stc & STC.scopeinferred) |
| tf.isscopeinferred = true; |
| |
| // if (tf.isreturn && !tf.isref) |
| // tf.isScopeQual = true; // return by itself means 'return scope' |
| |
| if (tf.trust == TRUST.default_) |
| { |
| if (sc.stc & STC.safe) |
| tf.trust = TRUST.safe; |
| else if (sc.stc & STC.system) |
| tf.trust = TRUST.system; |
| else if (sc.stc & STC.trusted) |
| tf.trust = TRUST.trusted; |
| } |
| |
| if (sc.stc & STC.property) |
| tf.isproperty = true; |
| if (sc.stc & STC.live) |
| tf.islive = true; |
| |
| tf.linkage = sc.linkage; |
| if (tf.linkage == LINK.system) |
| tf.linkage = target.systemLinkage(); |
| |
| version (none) |
| { |
| /* If the parent is @safe, then this function defaults to safe |
| * too. |
| * If the parent's @safe-ty is inferred, then this function's @safe-ty needs |
| * to be inferred first. |
| */ |
| if (tf.trust == TRUST.default_) |
| for (Dsymbol p = sc.func; p; p = p.toParent2()) |
| { |
| FuncDeclaration fd = p.isFuncDeclaration(); |
| if (fd) |
| { |
| if (fd.isSafeBypassingInference()) |
| tf.trust = TRUST.safe; // default to @safe |
| break; |
| } |
| } |
| } |
| |
| bool wildreturn = false; |
| if (tf.next) |
| { |
| sc = sc.push(); |
| sc.stc &= ~(STC.TYPECTOR | STC.FUNCATTR); |
| tf.next = tf.next.typeSemantic(loc, sc); |
| sc = sc.pop(); |
| errors |= tf.checkRetType(loc); |
| if (tf.next.isscope() && !tf.isctor) |
| { |
| .error(loc, "functions cannot return `scope %s`", tf.next.toChars()); |
| errors = true; |
| } |
| if (tf.next.hasWild()) |
| wildreturn = true; |
| |
| if (tf.isreturn && !tf.isref && !tf.next.hasPointers()) |
| { |
| tf.isreturn = false; |
| } |
| } |
| |
| /// Perform semantic on the default argument to a parameter |
| /// Modify the `defaultArg` field of `fparam`, which must not be `null` |
| /// Returns `false` whether an error was encountered. |
| static bool defaultArgSemantic (ref Parameter fparam, Scope* sc) |
| { |
| Expression e = fparam.defaultArg; |
| const isRefOrOut = fparam.isReference(); |
| const isAuto = fparam.storageClass & (STC.auto_ | STC.autoref); |
| if (isRefOrOut && !isAuto) |
| { |
| e = e.expressionSemantic(sc); |
| e = resolveProperties(sc, e); |
| } |
| else |
| { |
| e = inferType(e, fparam.type); |
| Initializer iz = new ExpInitializer(e.loc, e); |
| iz = iz.initializerSemantic(sc, fparam.type, INITnointerpret); |
| e = iz.initializerToExpression(); |
| } |
| if (e.op == EXP.function_) // https://issues.dlang.org/show_bug.cgi?id=4820 |
| { |
| FuncExp fe = e.isFuncExp(); |
| // Replace function literal with a function symbol, |
| // since default arg expression must be copied when used |
| // and copying the literal itself is wrong. |
| e = new VarExp(e.loc, fe.fd, false); |
| e = new AddrExp(e.loc, e); |
| e = e.expressionSemantic(sc); |
| } |
| if (isRefOrOut && (!isAuto || e.isLvalue()) |
| && !MODimplicitConv(e.type.mod, fparam.type.mod)) |
| { |
| const(char)* errTxt = fparam.storageClass & STC.ref_ ? "ref" : "out"; |
| .error(e.loc, "expression `%s` of type `%s` is not implicitly convertible to type `%s %s` of parameter `%s`", |
| e.toChars(), e.type.toChars(), errTxt, fparam.type.toChars(), fparam.toChars()); |
| } |
| e = e.implicitCastTo(sc, fparam.type); |
| |
| // default arg must be an lvalue |
| if (isRefOrOut && !isAuto && |
| !(global.params.previewIn && (fparam.storageClass & STC.in_)) && |
| global.params.rvalueRefParam != FeatureState.enabled) |
| e = e.toLvalue(sc, e); |
| |
| fparam.defaultArg = e; |
| return (e.op != EXP.error); |
| } |
| |
| ubyte wildparams = 0; |
| if (tf.parameterList.parameters) |
| { |
| /* Create a scope for evaluating the default arguments for the parameters |
| */ |
| Scope* argsc = sc.push(); |
| argsc.stc = 0; // don't inherit storage class |
| argsc.visibility = Visibility(Visibility.Kind.public_); |
| argsc.func = null; |
| |
| size_t dim = tf.parameterList.length; |
| for (size_t i = 0; i < dim; i++) |
| { |
| Parameter fparam = tf.parameterList[i]; |
| fparam.storageClass |= STC.parameter; |
| mtype.inuse++; |
| fparam.type = fparam.type.typeSemantic(loc, argsc); |
| mtype.inuse--; |
| |
| if (fparam.type.ty == Terror) |
| { |
| errors = true; |
| continue; |
| } |
| |
| fparam.type = fparam.type.addStorageClass(fparam.storageClass); |
| |
| if (fparam.storageClass & (STC.auto_ | STC.alias_ | STC.static_)) |
| { |
| if (!fparam.type) |
| continue; |
| } |
| |
| fparam.type = fparam.type.cAdjustParamType(sc); // adjust C array and function parameter types |
| |
| Type t = fparam.type.toBasetype(); |
| |
| /* If fparam after semantic() turns out to be a tuple, the number of parameters may |
| * change. |
| */ |
| if (auto tt = t.isTypeTuple()) |
| { |
| /* TypeFunction::parameter also is used as the storage of |
| * Parameter objects for FuncDeclaration. So we should copy |
| * the elements of TypeTuple::arguments to avoid unintended |
| * sharing of Parameter object among other functions. |
| */ |
| if (tt.arguments && tt.arguments.length) |
| { |
| /* Propagate additional storage class from tuple parameters to their |
| * element-parameters. |
| * Make a copy, as original may be referenced elsewhere. |
| */ |
| size_t tdim = tt.arguments.length; |
| auto newparams = new Parameters(tdim); |
| for (size_t j = 0; j < tdim; j++) |
| { |
| Parameter narg = (*tt.arguments)[j]; |
| |
| // https://issues.dlang.org/show_bug.cgi?id=12744 |
| // If the storage classes of narg |
| // conflict with the ones in fparam, it's ignored. |
| StorageClass stc = fparam.storageClass | narg.storageClass; |
| StorageClass stc1 = fparam.storageClass & (STC.ref_ | STC.out_ | STC.lazy_); |
| StorageClass stc2 = narg.storageClass & (STC.ref_ | STC.out_ | STC.lazy_); |
| if (stc1 && stc2 && stc1 != stc2) |
| { |
| OutBuffer buf1; stcToBuffer(&buf1, stc1 | ((stc1 & STC.ref_) ? (fparam.storageClass & STC.auto_) : 0)); |
| OutBuffer buf2; stcToBuffer(&buf2, stc2); |
| |
| .error(loc, "incompatible parameter storage classes `%s` and `%s`", |
| buf1.peekChars(), buf2.peekChars()); |
| errors = true; |
| stc = stc1 | (stc & ~(STC.ref_ | STC.out_ | STC.lazy_)); |
| } |
| (*newparams)[j] = new Parameter( |
| stc, narg.type, narg.ident, narg.defaultArg, narg.userAttribDecl); |
| } |
| fparam.type = new TypeTuple(newparams); |
| fparam.type = fparam.type.typeSemantic(loc, argsc); |
| } |
| fparam.storageClass = STC.parameter; |
| |
| /* Reset number of parameters, and back up one to do this fparam again, |
| * now that it is a tuple |
| */ |
| dim = tf.parameterList.length; |
| i--; |
| continue; |
| } |
| |
| // -preview=in: Always add `ref` when used with `extern(C++)` functions |
| // Done here to allow passing opaque types with `in` |
| if (global.params.previewIn && (fparam.storageClass & (STC.in_ | STC.ref_)) == STC.in_) |
| { |
| switch (tf.linkage) |
| { |
| case LINK.cpp: |
| fparam.storageClass |= STC.ref_; |
| break; |
| case LINK.default_, LINK.d: |
| break; |
| default: |
| .error(loc, "cannot use `in` parameters with `extern(%s)` functions", |
| linkageToChars(tf.linkage)); |
| .errorSupplemental(loc, "parameter `%s` declared as `in` here", fparam.toChars()); |
| break; |
| } |
| } |
| |
| if (t.ty == Tfunction) |
| { |
| .error(loc, "cannot have parameter of function type `%s`", fparam.type.toChars()); |
| errors = true; |
| } |
| else if (!fparam.isReference() && |
| (t.ty == Tstruct || t.ty == Tsarray || t.ty == Tenum)) |
| { |
| Type tb2 = t.baseElemOf(); |
| if (tb2.ty == Tstruct && !tb2.isTypeStruct().sym.members || |
| tb2.ty == Tenum && !tb2.isTypeEnum().sym.memtype) |
| { |
| if (global.params.previewIn && (fparam.storageClass & STC.in_)) |
| { |
| .error(loc, "cannot infer `ref` for `in` parameter `%s` of opaque type `%s`", |
| fparam.toChars(), fparam.type.toChars()); |
| } |
| else |
| .error(loc, "cannot have parameter of opaque type `%s` by value", |
| fparam.type.toChars()); |
| errors = true; |
| } |
| } |
| else if (!fparam.isLazy() && t.ty == Tvoid) |
| { |
| .error(loc, "cannot have parameter of type `%s`", fparam.type.toChars()); |
| errors = true; |
| } |
| |
| const bool isTypesafeVariadic = i + 1 == dim && |
| tf.parameterList.varargs == VarArg.typesafe && |
| (t.isTypeDArray() || t.isTypeClass()); |
| if (isTypesafeVariadic) |
| { |
| /* typesafe variadic arguments are constructed on the stack, so must be `scope` |
| */ |
| fparam.storageClass |= STC.scope_ | STC.scopeinferred; |
| } |
| |
| if (fparam.storageClass & STC.return_) |
| { |
| if (!fparam.isReference()) |
| { |
| if (!(fparam.storageClass & STC.scope_)) |
| fparam.storageClass |= STC.scope_ | STC.scopeinferred; // 'return' implies 'scope' |
| if (tf.isref) |
| { |
| } |
| else if (tf.next && !tf.next.hasPointers() && tf.next.toBasetype().ty != Tvoid) |
| { |
| fparam.storageClass &= ~STC.return_; // https://issues.dlang.org/show_bug.cgi?id=18963 |
| } |
| } |
| |
| if (isTypesafeVariadic) |
| { |
| /* This is because they can be constructed on the stack |
| * https://dlang.org/spec/function.html#typesafe_variadic_functions |
| */ |
| .error(loc, "typesafe variadic function parameter `%s` of type `%s` cannot be marked `return`", |
| fparam.ident ? fparam.ident.toChars() : "", t.toChars()); |
| errors = true; |
| } |
| } |
| |
| if (fparam.storageClass & STC.out_) |
| { |
| if (ubyte m = fparam.type.mod & (MODFlags.immutable_ | MODFlags.const_ | MODFlags.wild)) |
| { |
| .error(loc, "cannot have `%s out` parameter of type `%s`", MODtoChars(m), t.toChars()); |
| errors = true; |
| } |
| else |
| { |
| Type tv = t.baseElemOf(); |
| if (tv.ty == Tstruct && tv.isTypeStruct().sym.noDefaultCtor) |
| { |
| .error(loc, "cannot have `out` parameter of type `%s` because the default construction is disabled", fparam.type.toChars()); |
| errors = true; |
| } |
| } |
| } |
| |
| if (t.hasWild()) |
| { |
| wildparams |= 1; |
| //if (tf.next && !wildreturn) |
| // error(loc, "inout on parameter means inout must be on return type as well (if from D1 code, replace with `ref`)"); |
| } |
| |
| /* Scope attribute is not necessary if the parameter type does not have pointers |
| */ |
| const sr = buildScopeRef(fparam.storageClass); |
| switch (sr) |
| { |
| case ScopeRef.Scope: |
| case ScopeRef.RefScope: |
| case ScopeRef.ReturnRef_Scope: |
| if (!fparam.type.hasPointers()) |
| fparam.storageClass &= ~STC.scope_; |
| break; |
| |
| case ScopeRef.ReturnScope: |
| case ScopeRef.Ref_ReturnScope: |
| if (!fparam.type.hasPointers()) |
| fparam.storageClass &= ~(STC.return_ | STC.scope_ | STC.returnScope); |
| break; |
| |
| default: |
| break; |
| } |
| |
| // Remove redundant storage classes for type, they are already applied |
| fparam.storageClass &= ~(STC.TYPECTOR); |
| |
| // -preview=in: add `ref` storage class to suited `in` params |
| if (global.params.previewIn && (fparam.storageClass & (STC.in_ | STC.ref_)) == STC.in_) |
| { |
| auto ts = t.baseElemOf().isTypeStruct(); |
| const isPOD = !ts || ts.sym.isPOD(); |
| if (!isPOD || target.preferPassByRef(t)) |
| fparam.storageClass |= STC.ref_; |
| } |
| } |
| |
| // Now that we completed semantic for the argument types, |
| // run semantic on their default values, |
| // bearing in mind tuples have been expanded. |
| // We need to keep a pair of [oidx, eidx] (original index, |
| // extended index), as we need to run semantic when `oidx` changes. |
| size_t tupleOrigIdx = size_t.max; |
| size_t tupleExtIdx = size_t.max; |
| foreach (oidx, oparam, eidx, eparam; tf.parameterList) |
| { |
| // oparam (original param) will always have the default arg |
| // if there's one, but `eparam` will not if it's an expanded |
| // tuple. When we see an expanded tuple, we need to save its |
| // position to get the offset in it later on. |
| if (oparam.defaultArg) |
| { |
| // Get the obvious case out of the way |
| if (oparam is eparam) |
| errors |= !defaultArgSemantic(eparam, argsc); |
| // We're seeing a new tuple |
| else if (tupleOrigIdx == size_t.max || tupleOrigIdx < oidx) |
| { |
| /* https://issues.dlang.org/show_bug.cgi?id=18572 |
| * |
| * If a tuple parameter has a default argument, when expanding the parameter |
| * tuple the default argument tuple must also be expanded. |
| */ |
| tupleOrigIdx = oidx; |
| tupleExtIdx = eidx; |
| errors |= !defaultArgSemantic(oparam, argsc); |
| TupleExp te = oparam.defaultArg.isTupleExp(); |
| if (te && te.exps && te.exps.length) |
| eparam.defaultArg = (*te.exps)[0]; |
| } |
| // Processing an already-seen tuple |
| else |
| { |
| TupleExp te = oparam.defaultArg.isTupleExp(); |
| if (te && te.exps && te.exps.length) |
| eparam.defaultArg = (*te.exps)[eidx - tupleExtIdx]; |
| } |
| } |
| |
| // We need to know the default argument to resolve `auto ref`, |
| // hence why this has to take place as the very last step. |
| /* Resolve "auto ref" storage class to be either ref or value, |
| * based on the argument matching the parameter |
| */ |
| if (eparam.storageClass & STC.auto_) |
| { |
| Expression farg = mtype.fargs && eidx < mtype.fargs.length ? |
| (*mtype.fargs)[eidx] : eparam.defaultArg; |
| if (farg && (eparam.storageClass & STC.ref_)) |
| { |
| if (!farg.isLvalue()) |
| eparam.storageClass &= ~STC.ref_; // value parameter |
| eparam.storageClass &= ~STC.auto_; // https://issues.dlang.org/show_bug.cgi?id=14656 |
| eparam.storageClass |= STC.autoref; |
| } |
| else if (mtype.incomplete && (eparam.storageClass & STC.ref_)) |
| { |
| // the default argument may have been temporarily removed, |
| // see usage of `TypeFunction.incomplete`. |
| // https://issues.dlang.org/show_bug.cgi?id=19891 |
| eparam.storageClass &= ~STC.auto_; |
| eparam.storageClass |= STC.autoref; |
| } |
| else if (eparam.storageClass & STC.ref_) |
| { |
| .error(loc, "cannot explicitly instantiate template function with `auto ref` parameter"); |
| errors = true; |
| } |
| else |
| { |
| .error(loc, "`auto` can only be used as part of `auto ref` for template function parameters"); |
| errors = true; |
| } |
| } |
| } |
| |
| argsc.pop(); |
| } |
| if (tf.isWild()) |
| wildparams |= 2; |
| |
| if (wildreturn && !wildparams) |
| { |
| .error(loc, "`inout` on `return` means `inout` must be on a parameter as well for `%s`", mtype.toChars()); |
| errors = true; |
| } |
| tf.isInOutParam = (wildparams & 1) != 0; |
| tf.isInOutQual = (wildparams & 2) != 0; |
| |
| if (tf.isproperty && (tf.parameterList.varargs != VarArg.none || tf.parameterList.length > 2)) |
| { |
| .error(loc, "properties can only have zero, one, or two parameter"); |
| errors = true; |
| } |
| |
| if (tf.parameterList.varargs == VarArg.variadic && tf.linkage != LINK.d && tf.parameterList.length == 0 && |
| !(sc.flags & SCOPE.Cfile)) |
| { |
| .error(loc, "variadic functions with non-D linkage must have at least one parameter"); |
| errors = true; |
| } |
| |
| if (errors) |
| return error(); |
| |
| if (tf.next) |
| tf.deco = tf.merge().deco; |
| |
| /* Don't return merge(), because arg identifiers and default args |
| * can be different |
| * even though the types match |
| */ |
| return tf; |
| } |
| |
| Type visitDelegate(TypeDelegate mtype) |
| { |
| //printf("TypeDelegate::semantic() %s\n", mtype.toChars()); |
| if (mtype.deco) // if semantic() already run |
| { |
| //printf("already done\n"); |
| return mtype; |
| } |
| mtype.next = mtype.next.typeSemantic(loc, sc); |
| if (mtype.next.ty != Tfunction) |
| return error(); |
| |
| /* In order to deal with https://issues.dlang.org/show_bug.cgi?id=4028 |
| * perhaps default arguments should |
| * be removed from next before the merge. |
| */ |
| version (none) |
| { |
| return mtype.merge(); |
| } |
| else |
| { |
| /* Don't return merge(), because arg identifiers and default args |
| * can be different |
| * even though the types match |
| */ |
| mtype.deco = mtype.merge().deco; |
| return mtype; |
| } |
| } |
| |
| Type visitIdentifier(TypeIdentifier mtype) |
| { |
| Type t; |
| Expression e; |
| Dsymbol s; |
| //printf("TypeIdentifier::semantic(%s)\n", mtype.toChars()); |
| mtype.resolve(loc, sc, e, t, s); |
| if (t) |
| { |
| //printf("\tit's a type %d, %s, %s\n", t.ty, t.toChars(), t.deco); |
| return t.addMod(mtype.mod); |
| } |
| else |
| { |
| if (s) |
| { |
| auto td = s.isTemplateDeclaration; |
| if (td && td.onemember && td.onemember.isAggregateDeclaration) |
| .error(loc, "template %s `%s` is used as a type without instantiation" |
| ~ "; to instantiate it use `%s!(arguments)`", |
| s.kind, s.toPrettyChars, s.ident.toChars); |
| else |
| .error(loc, "%s `%s` is used as a type", s.kind, s.toPrettyChars); |
| //assert(0); |
| } |
| else if (e.op == EXP.variable) // special case: variable is used as a type |
| { |
| /* |
| N.B. This branch currently triggers for the following code |
| template test(x* x) |
| { |
| |
| } |
| i.e. the compiler prints "variable x is used as a type" |
| which isn't a particularly good error message (x is a variable?). |
| */ |
| Dsymbol varDecl = mtype.toDsymbol(sc); |
| const(Loc) varDeclLoc = varDecl.getLoc(); |
| Module varDeclModule = varDecl.getModule(); //This can be null |
| |
| .error(loc, "variable `%s` is used as a type", mtype.toChars()); |
| //Check for null to avoid https://issues.dlang.org/show_bug.cgi?id=22574 |
| if ((varDeclModule !is null) && varDeclModule != sc._module) // variable is imported |
| { |
| const(Loc) varDeclModuleImportLoc = varDeclModule.getLoc(); |
| .errorSupplemental( |
| varDeclModuleImportLoc, |
| "variable `%s` is imported here from: `%s`", |
| varDecl.toChars, |
| varDeclModule.toPrettyChars, |
| ); |
| } |
| |
| .errorSupplemental(varDeclLoc, "variable `%s` is declared here", varDecl.toChars); |
| } |
| else |
| .error(loc, "`%s` is used as a type", mtype.toChars()); |
| return error(); |
| } |
| } |
| |
| Type visitInstance(TypeInstance mtype) |
| { |
| Type t; |
| Expression e; |
| Dsymbol s; |
| |
| //printf("TypeInstance::semantic(%p, %s)\n", this, toChars()); |
| { |
| const errors = global.errors; |
| mtype.resolve(loc, sc, e, t, s); |
| // if we had an error evaluating the symbol, suppress further errors |
| if (!t && errors != global.errors) |
| return error(); |
| } |
| |
| if (!t) |
| { |
| if (!e && s && s.errors) |
| { |
| // if there was an error evaluating the symbol, it might actually |
| // be a type. Avoid misleading error messages. |
| .error(loc, "`%s` had previous errors", mtype.toChars()); |
| } |
| else |
| .error(loc, "`%s` is used as a type", mtype.toChars()); |
| return error(); |
| } |
| return t; |
| } |
| |
| Type visitTypeof(TypeTypeof mtype) |
| { |
| //printf("TypeTypeof::semantic() %s\n", mtype.toChars()); |
| Expression e; |
| Type t; |
| Dsymbol s; |
| mtype.resolve(loc, sc, e, t, s); |
| if (s && (t = s.getType()) !is null) |
| t = t.addMod(mtype.mod); |
| if (!t) |
| { |
| .error(loc, "`%s` is used as a type", mtype.toChars()); |
| return error(); |
| } |
| return t; |
| } |
| |
| Type visitTraits(TypeTraits mtype) |
| { |
| Expression e; |
| Type t; |
| Dsymbol s; |
| mtype.resolve(loc, sc, e, t, s); |
| |
| if (!t) |
| { |
| if (!global.errors) |
| .error(mtype.loc, "`%s` does not give a valid type", mtype.toChars); |
| return error(); |
| } |
| return t; |
| } |
| |
| Type visitReturn(TypeReturn mtype) |
| { |
| //printf("TypeReturn::semantic() %s\n", toChars()); |
| Expression e; |
| Type t; |
| Dsymbol s; |
| mtype.resolve(loc, sc, e, t, s); |
| if (s && (t = s.getType()) !is null) |
| t = t.addMod(mtype.mod); |
| if (!t) |
| { |
| .error(loc, "`%s` is used as a type", mtype.toChars()); |
| return error(); |
| } |
| return t; |
| } |
| |
| Type visitStruct(TypeStruct mtype) |
| { |
| //printf("TypeStruct::semantic('%s')\n", mtype.toChars()); |
| if (mtype.deco) |
| return mtype; |
| |
| /* Don't semantic for sym because it should be deferred until |
| * sizeof needed or its members accessed. |
| */ |
| // instead, parent should be set correctly |
| assert(mtype.sym.parent); |
| |
| if (mtype.sym.type.ty == Terror) |
| return error(); |
| |
| return merge(mtype); |
| } |
| |
| Type visitEnum(TypeEnum mtype) |
| { |
| //printf("TypeEnum::semantic() %s\n", toChars()); |
| return mtype.deco ? mtype : merge(mtype); |
| } |
| |
| Type visitClass(TypeClass mtype) |
| { |
| //printf("TypeClass::semantic(%s)\n", mtype.toChars()); |
| if (mtype.deco) |
| return mtype; |
| |
| /* Don't semantic for sym because it should be deferred until |
| * sizeof needed or its members accessed. |
| */ |
| // instead, parent should be set correctly |
| assert(mtype.sym.parent); |
| |
| if (mtype.sym.type.ty == Terror) |
| return error(); |
| |
| return merge(mtype); |
| } |
| |
| Type visitTuple(TypeTuple mtype) |
| { |
| //printf("TypeTuple::semantic(this = %p)\n", this); |
| //printf("TypeTuple::semantic() %p, %s\n", this, toChars()); |
| if (!mtype.deco) |
| mtype.deco = merge(mtype).deco; |
| |
| /* Don't return merge(), because a tuple with one type has the |
| * same deco as that type. |
| */ |
| return mtype; |
| } |
| |
| Type visitSlice(TypeSlice mtype) |
| { |
| //printf("TypeSlice::semantic() %s\n", toChars()); |
| Type tn = mtype.next.typeSemantic(loc, sc); |
| //printf("next: %s\n", tn.toChars()); |
| |
| Type tbn = tn.toBasetype(); |
| if (tbn.ty != Ttuple) |
| { |
| .error(loc, "can only slice tuple types, not `%s`", tbn.toChars()); |
| return error(); |
| } |
| TypeTuple tt = cast(TypeTuple)tbn; |
| |
| mtype.lwr = semanticLength(sc, tbn, mtype.lwr); |
| mtype.upr = semanticLength(sc, tbn, mtype.upr); |
| mtype.lwr = mtype.lwr.ctfeInterpret(); |
| mtype.upr = mtype.upr.ctfeInterpret(); |
| if (mtype.lwr.op == EXP.error || mtype.upr.op == EXP.error) |
| return error(); |
| |
| uinteger_t i1 = mtype.lwr.toUInteger(); |
| uinteger_t i2 = mtype.upr.toUInteger(); |
| if (!(i1 <= i2 && i2 <= tt.arguments.length)) |
| { |
| .error(loc, "slice `[%llu..%llu]` is out of range of `[0..%llu]`", |
| cast(ulong)i1, cast(ulong)i2, cast(ulong)tt.arguments.length); |
| return error(); |
| } |
| |
| mtype.next = tn; |
| mtype.transitive(); |
| |
| auto args = new Parameters(); |
| args.reserve(cast(size_t)(i2 - i1)); |
| foreach (arg; (*tt.arguments)[cast(size_t)i1 .. cast(size_t)i2]) |
| { |
| args.push(arg); |
| } |
| Type t = new TypeTuple(args); |
| return t.typeSemantic(loc, sc); |
| } |
| |
| Type visitMixin(TypeMixin mtype) |
| { |
| //printf("TypeMixin::semantic() %s\n", toChars()); |
| |
| Expression e; |
| Type t; |
| Dsymbol s; |
| mtype.resolve(loc, sc, e, t, s); |
| |
| if (t && t.ty != Terror) |
| return t; |
| |
| .error(mtype.loc, "`mixin(%s)` does not give a valid type", mtype.obj.toChars); |
| return error(); |
| } |
| |
| Type visitTag(TypeTag mtype) |
| { |
| //printf("TypeTag.semantic() %s\n", mtype.toChars()); |
| if (mtype.resolved) |
| { |
| /* struct S s, *p; |
| */ |
| return mtype.resolved.addSTC(mtype.mod); |
| } |
| |
| /* Find the current scope by skipping tag scopes. |
| * In C, tag scopes aren't considered scopes. |
| */ |
| Scope* sc2 = sc; |
| while (1) |
| { |
| sc2 = sc2.inner(); |
| auto scopesym = sc2.scopesym; |
| if (scopesym.isStructDeclaration()) |
| { |
| sc2 = sc2.enclosing; |
| continue; |
| } |
| break; |
| } |
| |
| /* Declare mtype as a struct/union/enum declaration |
| */ |
| void declareTag() |
| { |
| void declare(ScopeDsymbol sd) |
| { |
| sd.members = mtype.members; |
| auto scopesym = sc2.inner().scopesym; |
| if (scopesym.members) |
| scopesym.members.push(sd); |
| if (scopesym.symtab && !scopesym.symtabInsert(sd)) |
| { |
| Dsymbol s2 = scopesym.symtabLookup(sd, mtype.id); |
| handleTagSymbols(*sc2, sd, s2, scopesym); |
| } |
| sd.parent = sc2.parent; |
| sd.dsymbolSemantic(sc2); |
| } |
| |
| switch (mtype.tok) |
| { |
| case TOK.enum_: |
| auto ed = new EnumDeclaration(mtype.loc, mtype.id, mtype.base); |
| declare(ed); |
| mtype.resolved = visitEnum(new TypeEnum(ed)); |
| break; |
| |
| case TOK.struct_: |
| auto sd = new StructDeclaration(mtype.loc, mtype.id, false); |
| declare(sd); |
| mtype.resolved = visitStruct(new TypeStruct(sd)); |
| break; |
| |
| case TOK.union_: |
| auto ud = new UnionDeclaration(mtype.loc, mtype.id); |
| declare(ud); |
| mtype.resolved = visitStruct(new TypeStruct(ud)); |
| break; |
| |
| default: |
| assert(0); |
| } |
| } |
| |
| /* If it doesn't have a tag by now, supply one. |
| * It'll be unique, and therefore introducing. |
| * Declare it, and done. |
| */ |
| if (!mtype.id) |
| { |
| mtype.id = Identifier.generateId("__tag"[]); |
| declareTag(); |
| return mtype.resolved.addSTC(mtype.mod); |
| } |
| |
| /* look for pre-existing declaration |
| */ |
| Dsymbol scopesym; |
| auto s = sc2.search(mtype.loc, mtype.id, &scopesym, IgnoreErrors | TagNameSpace); |
| if (!s || s.isModule()) |
| { |
| // no pre-existing declaration, so declare it |
| if (mtype.tok == TOK.enum_ && !mtype.members) |
| .error(mtype.loc, "`enum %s` is incomplete without members", mtype.id.toChars()); // C11 6.7.2.3-3 |
| declareTag(); |
| return mtype.resolved.addSTC(mtype.mod); |
| } |
| |
| /* A redeclaration only happens if both declarations are in |
| * the same scope |
| */ |
| const bool redeclar = (scopesym == sc2.inner().scopesym); |
| |
| if (redeclar) |
| { |
| if (mtype.tok == TOK.enum_ && s.isEnumDeclaration()) |
| { |
| auto ed = s.isEnumDeclaration(); |
| if (mtype.members && ed.members) |
| .error(mtype.loc, "`%s` already has members", mtype.id.toChars()); |
| else if (!ed.members) |
| { |
| ed.members = mtype.members; |
| } |
| else |
| { |
| } |
| mtype.resolved = ed.type; |
| } |
| else if (mtype.tok == TOK.union_ && s.isUnionDeclaration() || |
| mtype.tok == TOK.struct_ && s.isStructDeclaration()) |
| { |
| // Add members to original declaration |
| auto sd = s.isStructDeclaration(); |
| if (mtype.members && sd.members) |
| { |
| /* struct S { int b; }; |
| * struct S { int a; } *s; |
| */ |
| .error(mtype.loc, "`%s` already has members", mtype.id.toChars()); |
| } |
| else if (!sd.members) |
| { |
| /* struct S; |
| * struct S { int a; } *s; |
| */ |
| sd.members = mtype.members; |
| if (sd.semanticRun == PASS.semanticdone) |
| { |
| /* The first semantic pass marked `sd` as an opaque struct. |
| * Re-run semantic so that all newly assigned members are |
| * picked up and added to the symtab. |
| */ |
| sd.semanticRun = PASS.semantic; |
| sd.dsymbolSemantic(sc2); |
| } |
| } |
| else |
| { |
| /* struct S { int a; }; |
| * struct S *s; |
| */ |
| } |
| mtype.resolved = sd.type; |
| } |
| else |
| { |
| /* int S; |
| * struct S { int a; } *s; |
| */ |
| .error(mtype.loc, "redeclaration of `%s`", mtype.id.toChars()); |
| mtype.resolved = error(); |
| } |
| } |
| else if (mtype.members) |
| { |
| /* struct S; |
| * { struct S { int a; } *s; } |
| */ |
| declareTag(); |
| } |
| else |
| { |
| if (mtype.tok == TOK.enum_ && s.isEnumDeclaration()) |
| { |
| mtype.resolved = s.isEnumDeclaration().type; |
| } |
| else if (mtype.tok == TOK.union_ && s.isUnionDeclaration() || |
| mtype.tok == TOK.struct_ && s.isStructDeclaration()) |
| { |
| /* struct S; |
| * { struct S *s; } |
| */ |
| mtype.resolved = s.isStructDeclaration().type; |
| } |
| else |
| { |
| /* union S; |
| * { struct S *s; } |
| */ |
| .error(mtype.loc, "redeclaring `%s %s` as `%s %s`", |
| s.kind(), s.toChars(), Token.toChars(mtype.tok), mtype.id.toChars()); |
| declareTag(); |
| } |
| } |
| return mtype.resolved.addSTC(mtype.mod); |
| } |
| |
| switch (type.ty) |
| { |
| default: return visitType(type); |
| case Tvector: return visitVector(type.isTypeVector()); |
| case Tsarray: return visitSArray(type.isTypeSArray()); |
| case Tarray: return visitDArray(type.isTypeDArray()); |
| case Taarray: return visitAArray(type.isTypeAArray()); |
| case Tpointer: return visitPointer(type.isTypePointer()); |
| case Treference: return visitReference(type.isTypeReference()); |
| case Tfunction: return visitFunction(type.isTypeFunction()); |
| case Tdelegate: return visitDelegate(type.isTypeDelegate()); |
| case Tident: return visitIdentifier(type.isTypeIdentifier()); |
| case Tinstance: return visitInstance(type.isTypeInstance()); |
| case Ttypeof: return visitTypeof(type.isTypeTypeof()); |
| case Ttraits: return visitTraits(type.isTypeTraits()); |
| case Treturn: return visitReturn(type.isTypeReturn()); |
| case Tstruct: return visitStruct(type.isTypeStruct()); |
| case Tenum: return visitEnum(type.isTypeEnum()); |
| case Tclass: return visitClass(type.isTypeClass()); |
| case Ttuple: return visitTuple(type.isTypeTuple()); |
| case Tslice: return visitSlice(type.isTypeSlice()); |
| case Tmixin: return visitMixin(type.isTypeMixin()); |
| case Ttag: return visitTag(type.isTypeTag()); |
| } |
| } |
| |
| /************************************ |
| * If an identical type to `type` is in `type.stringtable`, return |
| * the latter one. Otherwise, add it to `type.stringtable`. |
| * Some types don't get merged and are returned as-is. |
| * Params: |
| * type = Type to check against existing types |
| * Returns: |
| * the type that was merged |
| */ |
| extern (C++) Type merge(Type type) |
| { |
| switch (type.ty) |
| { |
| case Terror: |
| case Ttypeof: |
| case Tident: |
| case Tinstance: |
| case Tmixin: |
| case Ttag: |
| return type; // don't merge placeholder types |
| |
| case Tsarray: |
| // prevents generating the mangle if the array dim is not yet known |
| if (!type.isTypeSArray().dim.isIntegerExp()) |
| return type; |
| goto default; |
| |
| case Tenum: |
| break; |
| |
| case Taarray: |
| if (!type.isTypeAArray().index.merge().deco) |
| return type; |
| goto default; |
| |
| default: |
| if (type.nextOf() && !type.nextOf().deco) |
| return type; |
| break; |
| } |
| |
| //printf("merge(%s)\n", toChars()); |
| if (!type.deco) |
| { |
| OutBuffer buf; |
| buf.reserve(32); |
| |
| mangleToBuffer(type, &buf); |
| |
| auto sv = type.stringtable.update(buf[]); |
| if (sv.value) |
| { |
| Type t = sv.value; |
| debug |
| { |
| import core.stdc.stdio; |
| if (!t.deco) |
| printf("t = %s\n", t.toChars()); |
| } |
| assert(t.deco); |
| //printf("old value, deco = '%s' %p\n", t.deco, t.deco); |
| return t; |
| } |
| else |
| { |
| Type t = stripDefaultArgs(type); |
| sv.value = t; |
| type.deco = t.deco = cast(char*)sv.toDchars(); |
| //printf("new value, deco = '%s' %p\n", t.deco, t.deco); |
| return t; |
| } |
| } |
| return type; |
| } |
| |
| /*************************************** |
| * Calculate built-in properties which just the type is necessary. |
| * |
| * Params: |
| * t = the type for which the property is calculated |
| * scope_ = the scope from which the property is being accessed. Used for visibility checks only. |
| * loc = the location where the property is encountered |
| * ident = the identifier of the property |
| * flag = if flag & 1, don't report "not a property" error and just return NULL. |
| * src = expression for type `t` or null. |
| * Returns: |
| * expression representing the property, or null if not a property and (flag & 1) |
| */ |
| Expression getProperty(Type t, Scope* scope_, const ref Loc loc, Identifier ident, int flag, |
| Expression src = null) |
| { |
| Expression visitType(Type mt) |
| { |
| Expression e; |
| static if (LOGDOTEXP) |
| { |
| printf("Type::getProperty(type = '%s', ident = '%s')\n", mt.toChars(), ident.toChars()); |
| } |
| if (ident == Id.__sizeof) |
| { |
| const sz = mt.size(loc); |
| if (sz == SIZE_INVALID) |
| return ErrorExp.get(); |
| e = new IntegerExp(loc, sz, Type.tsize_t); |
| } |
| else if (ident == Id.__xalignof) |
| { |
| const explicitAlignment = mt.alignment(); |
| const naturalAlignment = mt.alignsize(); |
| const actualAlignment = (explicitAlignment.isDefault() ? naturalAlignment : explicitAlignment.get()); |
| e = new IntegerExp(loc, actualAlignment, Type.tsize_t); |
| } |
| else if (ident == Id._init) |
| { |
| Type tb = mt.toBasetype(); |
| e = mt.defaultInitLiteral(loc); |
| if (tb.ty == Tstruct && tb.needsNested()) |
| { |
| e.isStructLiteralExp().useStaticInit = true; |
| } |
| } |
| else if (ident == Id._mangleof) |
| { |
| if (!mt.deco) |
| { |
| error(loc, "forward reference of type `%s.mangleof`", mt.toChars()); |
| e = ErrorExp.get(); |
| } |
| else |
| { |
| e = new StringExp(loc, mt.deco.toDString()); |
| Scope sc; |
| e = e.expressionSemantic(&sc); |
| } |
| } |
| else if (ident == Id.stringof) |
| { |
| const s = mt.toChars(); |
| e = new StringExp(loc, s.toDString()); |
| Scope sc; |
| e = e.expressionSemantic(&sc); |
| } |
| else if (flag && mt != Type.terror) |
| { |
| return null; |
| } |
| else |
| { |
| Dsymbol s = null; |
| if (mt.ty == Tstruct || mt.ty == Tclass || mt.ty == Tenum) |
| s = mt.toDsymbol(null); |
| if (s) |
| s = s.search_correct(ident); |
| if (s && !symbolIsVisible(scope_, s)) |
| s = null; |
| if (mt != Type.terror) |
| { |
| if (s) |
| error(loc, "no property `%s` for type `%s`, did you mean `%s`?", ident.toChars(), mt.toChars(), s.toPrettyChars()); |
| else if (ident == Id.call && mt.ty == Tclass) |
| error(loc, "no property `%s` for type `%s`, did you mean `new %s`?", ident.toChars(), mt.toChars(), mt.toPrettyChars()); |
| |
| else if (const n = importHint(ident.toString())) |
| error(loc, "no property `%s` for type `%s`, perhaps `import %.*s;` is needed?", ident.toChars(), mt.toChars(), cast(int)n.length, n.ptr); |
| else |
| { |
| if (src) |
| error(loc, "no property `%s` for `%s` of type `%s`", ident.toChars(), src.toChars(), mt.toPrettyChars(true)); |
| else |
| error(loc, "no property `%s` for type `%s`", ident.toChars(), mt.toPrettyChars(true)); |
| if (auto dsym = mt.toDsymbol(scope_)) |
| if (auto sym = dsym.isAggregateDeclaration()) |
| { |
| if (auto fd = search_function(sym, Id.opDispatch)) |
| errorSupplemental(loc, "potentially malformed `opDispatch`. Use an explicit instantiation to get a better error message"); |
| else if (!sym.members) |
| errorSupplemental(sym.loc, "`%s %s` is opaque and has no members.", sym.kind, mt.toPrettyChars(true)); |
| } |
| } |
| } |
| e = ErrorExp.get(); |
| } |
| return e; |
| } |
| |
| Expression visitError(TypeError) |
| { |
| return ErrorExp.get(); |
| } |
| |
| Expression visitBasic(TypeBasic mt) |
| { |
| Expression integerValue(dinteger_t i) |
| { |
| return new IntegerExp(loc, i, mt); |
| } |
| |
| Expression intValue(dinteger_t i) |
| { |
| return new IntegerExp(loc, i, Type.tint32); |
| } |
| |
| Expression floatValue(real_t r) |
| { |
| if (mt.isreal() || mt.isimaginary()) |
| return new RealExp(loc, r, mt); |
| else |
| { |
| return new ComplexExp(loc, complex_t(r, r), mt); |
| } |
| } |
| |
| //printf("TypeBasic::getProperty('%s')\n", ident.toChars()); |
| if (ident == Id.max) |
| { |
| switch (mt.ty) |
| { |
| case Tint8: return integerValue(byte.max); |
| case Tuns8: return integerValue(ubyte.max); |
| case Tint16: return integerValue(short.max); |
| case Tuns16: return integerValue(ushort.max); |
| case Tint32: return integerValue(int.max); |
| case Tuns32: return integerValue(uint.max); |
| case Tint64: return integerValue(long.max); |
| case Tuns64: return integerValue(ulong.max); |
| case Tbool: return integerValue(bool.max); |
| case Tchar: return integerValue(char.max); |
| case Twchar: return integerValue(wchar.max); |
| case Tdchar: return integerValue(dchar.max); |
| case Tcomplex32: |
| case Timaginary32: |
| case Tfloat32: return floatValue(target.FloatProperties.max); |
| case Tcomplex64: |
| case Timaginary64: |
| case Tfloat64: return floatValue(target.DoubleProperties.max); |
| case Tcomplex80: |
| case Timaginary80: |
| case Tfloat80: return floatValue(target.RealProperties.max); |
| default: break; |
| } |
| } |
| else if (ident == Id.min) |
| { |
| switch (mt.ty) |
| { |
| case Tint8: return integerValue(byte.min); |
| case Tuns8: |
| case Tuns16: |
| case Tuns32: |
| case Tuns64: |
| case Tbool: |
| case Tchar: |
| case Twchar: |
| case Tdchar: return integerValue(0); |
| case Tint16: return integerValue(short.min); |
| case Tint32: return integerValue(int.min); |
| case Tint64: return integerValue(long.min); |
| default: break; |
| } |
| } |
| else if (ident == Id.min_normal) |
| { |
| switch (mt.ty) |
| { |
| case Tcomplex32: |
| case Timaginary32: |
| case Tfloat32: return floatValue(target.FloatProperties.min_normal); |
| case Tcomplex64: |
| case Timaginary64: |
| case Tfloat64: return floatValue(target.DoubleProperties.min_normal); |
| case Tcomplex80: |
| case Timaginary80: |
| case Tfloat80: return floatValue(target.RealProperties.min_normal); |
| default: break; |
| } |
| } |
| else if (ident == Id.nan) |
| { |
| switch (mt.ty) |
| { |
| case Tcomplex32: |
| case Tcomplex64: |
| case Tcomplex80: |
| case Timaginary32: |
| case Timaginary64: |
| case Timaginary80: |
| case Tfloat32: |
| case Tfloat64: |
| case Tfloat80: return floatValue(target.RealProperties.nan); |
| default: break; |
| } |
| } |
| else if (ident == Id.infinity) |
| { |
| switch (mt.ty) |
| { |
| case Tcomplex32: |
| case Tcomplex64: |
| case Tcomplex80: |
| case Timaginary32: |
| case Timaginary64: |
| case Timaginary80: |
| case Tfloat32: |
| case Tfloat64: |
| case Tfloat80: return floatValue(target.RealProperties.infinity); |
| default: break; |
| } |
| } |
| else if (ident == Id.dig) |
| { |
| switch (mt.ty) |
| { |
| case Tcomplex32: |
| case Timaginary32: |
| case Tfloat32: return intValue(target.FloatProperties.dig); |
| case Tcomplex64: |
| case Timaginary64: |
| case Tfloat64: return intValue(target.DoubleProperties.dig); |
| case Tcomplex80: |
| case Timaginary80: |
| case Tfloat80: return intValue(target.RealProperties.dig); |
| default: break; |
| } |
| } |
| else if (ident == Id.epsilon) |
| { |
| switch (mt.ty) |
| { |
| case Tcomplex32: |
| case Timaginary32: |
| case Tfloat32: return floatValue(target.FloatProperties.epsilon); |
| case Tcomplex64: |
| case Timaginary64: |
| case Tfloat64: return floatValue(target.DoubleProperties.epsilon); |
| case Tcomplex80: |
| case Timaginary80: |
| case Tfloat80: return floatValue(target.RealProperties.epsilon); |
| default: break; |
| } |
| } |
| else if (ident == Id.mant_dig) |
| { |
| switch (mt.ty) |
| { |
| case Tcomplex32: |
| case Timaginary32: |
| case Tfloat32: return intValue(target.FloatProperties.mant_dig); |
| case Tcomplex64: |
| case Timaginary64: |
| case Tfloat64: return intValue(target.DoubleProperties.mant_dig); |
| case Tcomplex80: |
| case Timaginary80: |
| case Tfloat80: return intValue(target.RealProperties.mant_dig); |
| default: break; |
| } |
| } |
| else if (ident == Id.max_10_exp) |
| { |
| switch (mt.ty) |
| { |
| case Tcomplex32: |
| case Timaginary32: |
| case Tfloat32: return intValue(target.FloatProperties.max_10_exp); |
| case Tcomplex64: |
| case Timaginary64: |
| case Tfloat64: return intValue(target.DoubleProperties.max_10_exp); |
| case Tcomplex80: |
| case Timaginary80: |
| case Tfloat80: return intValue(target.RealProperties.max_10_exp); |
| default: break; |
| } |
| } |
| else if (ident == Id.max_exp) |
| { |
| switch (mt.ty) |
| { |
| case Tcomplex32: |
| case Timaginary32: |
| case Tfloat32: return intValue(target.FloatProperties.max_exp); |
| case Tcomplex64: |
| case Timaginary64: |
| case Tfloat64: return intValue(target.DoubleProperties.max_exp); |
| case Tcomplex80: |
| case Timaginary80: |
| case Tfloat80: return intValue(target.RealProperties.max_exp); |
| default: break; |
| } |
| } |
| else if (ident == Id.min_10_exp) |
| { |
| switch (mt.ty) |
| { |
| case Tcomplex32: |
| case Timaginary32: |
| case Tfloat32: return intValue(target.FloatProperties.min_10_exp); |
| case Tcomplex64: |
| case Timaginary64: |
| case Tfloat64: return intValue(target.DoubleProperties.min_10_exp); |
| case Tcomplex80: |
| case Timaginary80: |
| case Tfloat80: return intValue(target.RealProperties.min_10_exp); |
| default: break; |
| } |
| } |
| else if (ident == Id.min_exp) |
| { |
| switch (mt.ty) |
| { |
| case Tcomplex32: |
| case Timaginary32: |
| case Tfloat32: return intValue(target.FloatProperties.min_exp); |
| case Tcomplex64: |
| case Timaginary64: |
| case Tfloat64: return intValue(target.DoubleProperties.min_exp); |
| case Tcomplex80: |
| case Timaginary80: |
| case Tfloat80: return intValue(target.RealProperties.min_exp); |
| default: break; |
| } |
| } |
| return visitType(mt); |
| } |
| |
| Expression visitVector(TypeVector mt) |
| { |
| return visitType(mt); |
| } |
| |
| Expression visitEnum(TypeEnum mt) |
| { |
| Expression e; |
| if (ident == Id.max || ident == Id.min) |
| { |
| return mt.sym.getMaxMinValue(loc, ident); |
| } |
| else if (ident == Id._init) |
| { |
| e = mt.defaultInitLiteral(loc); |
| } |
| else if (ident == Id.stringof) |
| { |
| e = new StringExp(loc, mt.toString()); |
| Scope sc; |
| e = e.expressionSemantic(&sc); |
| } |
| else if (ident == Id._mangleof) |
| { |
| e = visitType(mt); |
| } |
| else |
| { |
| e = mt.toBasetype().getProperty(scope_, loc, ident, flag); |
| } |
| return e; |
| } |
| |
| Expression visitTuple(TypeTuple mt) |
| { |
| Expression e; |
| static if (LOGDOTEXP) |
| { |
| printf("TypeTuple::getProperty(type = '%s', ident = '%s')\n", mt.toChars(), ident.toChars()); |
| } |
| if (ident == Id.length) |
| { |
| e = new IntegerExp(loc, mt.arguments.length, Type.tsize_t); |
| } |
| else if (ident == Id._init) |
| { |
| e = mt.defaultInitLiteral(loc); |
| } |
| else if (flag) |
| { |
| e = null; |
| } |
| else |
| { |
| error(loc, "no property `%s` for tuple `%s`", ident.toChars(), mt.toChars()); |
| e = ErrorExp.get(); |
| } |
| return e; |
| } |
| |
| switch (t.ty) |
| { |
| default: return t.isTypeBasic() ? |
| visitBasic(cast(TypeBasic)t) : |
| visitType(t); |
| |
| case Terror: return visitError (t.isTypeError()); |
| case Tvector: return visitVector(t.isTypeVector()); |
| case Tenum: return visitEnum (t.isTypeEnum()); |
| case Ttuple: return visitTuple (t.isTypeTuple()); |
| } |
| } |
| |
| /*************************************** |
| * Determine if Expression `exp` should instead be a Type, a Dsymbol, or remain an Expression. |
| * Params: |
| * exp = Expression to look at |
| * t = if exp should be a Type, set t to that Type else null |
| * s = if exp should be a Dsymbol, set s to that Dsymbol else null |
| * e = if exp should remain an Expression, set e to that Expression else null |
| * |
| */ |
| private void resolveExp(Expression exp, out Type t, out Expression e, out Dsymbol s) |
| { |
| if (exp.isTypeExp()) |
| t = exp.type; |
| else if (auto ve = exp.isVarExp()) |
| { |
| if (auto v = ve.var.isVarDeclaration()) |
| e = exp; |
| else |
| s = ve.var; |
| } |
| else if (auto te = exp.isTemplateExp()) |
| s = te.td; |
| else if (auto se = exp.isScopeExp()) |
| s = se.sds; |
| else if (exp.isFuncExp()) |
| s = getDsymbol(exp); |
| else if (auto dte = exp.isDotTemplateExp()) |
| s = dte.td; |
| else if (exp.isErrorExp()) |
| t = Type.terror; |
| else |
| e = exp; |
| } |
| |
| /************************************ |
| * Resolve type 'mt' to either type, symbol, or expression. |
| * If errors happened, resolved to Type.terror. |
| * |
| * Params: |
| * mt = type to be resolved |
| * loc = the location where the type is encountered |
| * sc = the scope of the type |
| * pe = is set if t is an expression |
| * pt = is set if t is a type |
| * ps = is set if t is a symbol |
| * intypeid = true if in type id |
| */ |
| void resolve(Type mt, const ref Loc loc, Scope* sc, out Expression pe, out Type pt, out Dsymbol ps, bool intypeid = false) |
| { |
| void returnExp(Expression e) |
| { |
| pe = e; |
| pt = null; |
| ps = null; |
| } |
| |
| void returnType(Type t) |
| { |
| pe = null; |
| pt = t; |
| ps = null; |
| } |
| |
| void returnSymbol(Dsymbol s) |
| { |
| pe = null; |
| pt = null; |
| ps = s; |
| } |
| |
| void returnError() |
| { |
| returnType(Type.terror); |
| } |
| |
| void visitType(Type mt) |
| { |
| //printf("Type::resolve() %s, %d\n", mt.toChars(), mt.ty); |
| Type t = typeSemantic(mt, loc, sc); |
| assert(t); |
| returnType(t); |
| } |
| |
| void visitSArray(TypeSArray mt) |
| { |
| //printf("TypeSArray::resolve() %s\n", mt.toChars()); |
| mt.next.resolve(loc, sc, pe, pt, ps, intypeid); |
| //printf("s = %p, e = %p, t = %p\n", ps, pe, pt); |
| if (pe) |
| { |
| // It's really an index expression |
| if (Dsymbol s = getDsymbol(pe)) |
| pe = new DsymbolExp(loc, s); |
| returnExp(new ArrayExp(loc, pe, mt.dim)); |
| } |
| else if (ps) |
| { |
| Dsymbol s = ps; |
| if (auto tup = s.isTupleDeclaration()) |
| { |
| mt.dim = semanticLength(sc, tup, mt.dim); |
| mt.dim = mt.dim.ctfeInterpret(); |
| if (mt.dim.op == EXP.error) |
| return returnError(); |
| |
| const d = mt.dim.toUInteger(); |
| if (d >= tup.objects.length) |
| { |
| error(loc, "tuple index `%llu` out of bounds `[0 .. %llu]`", d, cast(ulong) tup.objects.length); |
| return returnError(); |
| } |
| |
| RootObject o = (*tup.objects)[cast(size_t)d]; |
| switch (o.dyncast()) with (DYNCAST) |
| { |
| case dsymbol: |
| return returnSymbol(cast(Dsymbol)o); |
| case expression: |
| Expression e = cast(Expression)o; |
| if (e.op == EXP.dSymbol) |
| return returnSymbol(e.isDsymbolExp().s); |
| else |
| return returnExp(e); |
| case type: |
| return returnType((cast(Type)o).addMod(mt.mod)); |
| default: |
| break; |
| } |
| |
| /* Create a new TupleDeclaration which |
| * is a slice [d..d+1] out of the old one. |
| * Do it this way because TemplateInstance::semanticTiargs() |
| * can handle unresolved Objects this way. |
| */ |
| auto objects = new Objects(1); |
| (*objects)[0] = o; |
| return returnSymbol(new TupleDeclaration(loc, tup.ident, objects)); |
| } |
| else |
| return visitType(mt); |
| } |
| else |
| { |
| if (pt.ty != Terror) |
| mt.next = pt; // prevent re-running semantic() on 'next' |
| visitType(mt); |
| } |
| |
| } |
| |
| void visitDArray(TypeDArray mt) |
| { |
| //printf("TypeDArray::resolve() %s\n", mt.toChars()); |
| mt.next.resolve(loc, sc, pe, pt, ps, intypeid); |
| //printf("s = %p, e = %p, t = %p\n", ps, pe, pt); |
| if (pe) |
| { |
| // It's really a slice expression |
| if (Dsymbol s = getDsymbol(pe)) |
| pe = new DsymbolExp(loc, s); |
| returnExp(new ArrayExp(loc, pe)); |
| } |
| else if (ps) |
| { |
| if (auto tup = ps.isTupleDeclaration()) |
| { |
| // keep ps |
| } |
| else |
| visitType(mt); |
| } |
| else |
| { |
| if (pt.ty != Terror) |
| mt.next = pt; // prevent re-running semantic() on 'next' |
| visitType(mt); |
| } |
| } |
| |
| void visitAArray(TypeAArray mt) |
| { |
| //printf("TypeAArray::resolve() %s\n", mt.toChars()); |
| // Deal with the case where we thought the index was a type, but |
| // in reality it was an expression. |
| if (mt.index.ty == Tident || mt.index.ty == Tinstance || mt.index.ty == Tsarray) |
| { |
| Expression e; |
| Type t; |
| Dsymbol s; |
| mt.index.resolve(loc, sc, e, t, s, intypeid); |
| if (e) |
| { |
| // It was an expression - |
| // Rewrite as a static array |
| auto tsa = new TypeSArray(mt.next, e); |
| tsa.mod = mt.mod; // just copy mod field so tsa's semantic is not yet done |
| return tsa.resolve(loc, sc, pe, pt, ps, intypeid); |
| } |
| else if (t) |
| mt.index = t; |
| else |
| .error(loc, "index is not a type or an expression"); |
| } |
| visitType(mt); |
| } |
| |
| /************************************* |
| * Takes an array of Identifiers and figures out if |
| * it represents a Type or an Expression. |
| * Output: |
| * if expression, pe is set |
| * if type, pt is set |
| */ |
| void visitIdentifier(TypeIdentifier mt) |
| { |
| //printf("TypeIdentifier::resolve(sc = %p, idents = '%s')\n", sc, mt.toChars()); |
| if (mt.ident == Id.ctfe) |
| { |
| error(loc, "variable `__ctfe` cannot be read at compile time"); |
| return returnError(); |
| } |
| if (mt.ident == Id.builtin_va_list) // gcc has __builtin_va_xxxx for stdarg.h |
| { |
| /* Since we don't support __builtin_va_start, -arg, -end, we don't |
| * have to actually care what -list is. A void* will do. |
| * If we ever do care, import core.stdc.stdarg and pull |
| * the definition out of that, similarly to how std.math is handled for PowExp |
| */ |
| pt = target.va_listType(loc, sc); |
| return; |
| } |
| |
| Dsymbol scopesym; |
| Dsymbol s = sc.search(loc, mt.ident, &scopesym); |
| /* |
| * https://issues.dlang.org/show_bug.cgi?id=1170 |
| * https://issues.dlang.org/show_bug.cgi?id=10739 |
| * |
| * If a symbol is not found, it might be declared in |
| * a mixin-ed string or a mixin-ed template, so before |
| * issuing an error semantically analyze all string/template |
| * mixins that are members of the current ScopeDsymbol. |
| */ |
| if (!s && sc.enclosing) |
| { |
| ScopeDsymbol sds = sc.enclosing.scopesym; |
| if (sds && sds.members) |
| { |
| void semanticOnMixin(Dsymbol member) |
| { |
| if (auto compileDecl = member.isCompileDeclaration()) |
| compileDecl.dsymbolSemantic(sc); |
| else if (auto mixinTempl = member.isTemplateMixin()) |
| mixinTempl.dsymbolSemantic(sc); |
| } |
| sds.members.foreachDsymbol( s => semanticOnMixin(s) ); |
| s = sc.search(loc, mt.ident, &scopesym); |
| } |
| } |
| |
| if (s) |
| { |
| // https://issues.dlang.org/show_bug.cgi?id=16042 |
| // If `f` is really a function template, then replace `f` |
| // with the function template declaration. |
| if (auto f = s.isFuncDeclaration()) |
| { |
| if (auto td = getFuncTemplateDecl(f)) |
| { |
| // If not at the beginning of the overloaded list of |
| // `TemplateDeclaration`s, then get the beginning |
| if (td.overroot) |
| td = td.overroot; |
| s = td; |
| } |
| } |
| } |
| |
| mt.resolveHelper(loc, sc, s, scopesym, pe, pt, ps, intypeid); |
| if (pt) |
| pt = pt.addMod(mt.mod); |
| } |
| |
| void visitInstance(TypeInstance mt) |
| { |
| // Note close similarity to TypeIdentifier::resolve() |
| |
| //printf("TypeInstance::resolve(sc = %p, tempinst = '%s')\n", sc, mt.tempinst.toChars()); |
| mt.tempinst.dsymbolSemantic(sc); |
| if (!global.gag && mt.tempinst.errors) |
| return returnError(); |
| |
| mt.resolveHelper(loc, sc, mt.tempinst, null, pe, pt, ps, intypeid); |
| if (pt) |
| pt = pt.addMod(mt.mod); |
| //if (pt) printf("pt = %d '%s'\n", pt.ty, pt.toChars()); |
| } |
| |
| void visitTypeof(TypeTypeof mt) |
| { |
| //printf("TypeTypeof::resolve(this = %p, sc = %p, idents = '%s')\n", mt, sc, mt.toChars()); |
| //static int nest; if (++nest == 50) *(char*)0=0; |
| if (sc is null) |
| { |
| error(loc, "invalid scope"); |
| return returnError(); |
| } |
| if (mt.inuse) |
| { |
| mt.inuse = 2; |
| error(loc, "circular `typeof` definition"); |
| Lerr: |
| mt.inuse--; |
| return returnError(); |
| } |
| mt.inuse++; |
| |
| /* Currently we cannot evaluate 'exp' in speculative context, because |
| * the type implementation may leak to the final execution. Consider: |
| * |
| * struct S(T) { |
| * string toString() const { return "x"; } |
| * } |
| * void main() { |
| * alias X = typeof(S!int()); |
| * assert(typeid(X).toString() == "x"); |
| * } |
| */ |
| Scope* sc2 = sc.push(); |
| |
| if (!mt.exp.isTypeidExp()) |
| /* Treat typeof(typeid(exp)) as needing |
| * the full semantic analysis of the typeid. |
| * https://issues.dlang.org/show_bug.cgi?id=20958 |
| */ |
| sc2.intypeof = 1; |
| |
| auto exp2 = mt.exp.expressionSemantic(sc2); |
| exp2 = resolvePropertiesOnly(sc2, exp2); |
| sc2.pop(); |
| |
| if (exp2.op == EXP.error) |
| { |
| if (!global.gag) |
| mt.exp = exp2; |
| goto Lerr; |
| } |
| mt.exp = exp2; |
| |
| if (mt.exp.op == EXP.type || |
| mt.exp.op == EXP.scope_) |
| { |
| if (!(sc.flags & SCOPE.Cfile) && // in (extended) C typeof may be used on types as with sizeof |
| mt.exp.checkType()) |
| goto Lerr; |
| |
| /* Today, 'typeof(func)' returns void if func is a |
| * function template (TemplateExp), or |
| * template lambda (FuncExp). |
| * It's actually used in Phobos as an idiom, to branch code for |
| * template functions. |
| */ |
| } |
| if (auto f = mt.exp.op == EXP.variable ? mt.exp.isVarExp().var.isFuncDeclaration() |
| : mt.exp.op == EXP.dotVariable ? mt.exp.isDotVarExp().var.isFuncDeclaration() : null) |
| { |
| // f might be a unittest declaration which is incomplete when compiled |
| // without -unittest. That causes a segfault in checkForwardRef, see |
| // https://issues.dlang.org/show_bug.cgi?id=20626 |
| if ((!f.isUnitTestDeclaration() || global.params.useUnitTests) && f.checkForwardRef(loc)) |
| goto Lerr; |
| } |
| if (auto f = isFuncAddress(mt.exp)) |
| { |
| if (f.checkForwardRef(loc)) |
| goto Lerr; |
| } |
| |
| Type t = mt.exp.type; |
| if (!t) |
| { |
| error(loc, "expression `%s` has no type", mt.exp.toChars()); |
| goto Lerr; |
| } |
| if (t.ty == Ttypeof) |
| { |
| error(loc, "forward reference to `%s`", mt.toChars()); |
| goto Lerr; |
| } |
| if (mt.idents.length == 0) |
| { |
| returnType(t.addMod(mt.mod)); |
| } |
| else |
| { |
| if (Dsymbol s = t.toDsymbol(sc)) |
| mt.resolveHelper(loc, sc, s, null, pe, pt, ps, intypeid); |
| else |
| { |
| auto e = typeToExpressionHelper(mt, new TypeExp(loc, t)); |
| e = e.expressionSemantic(sc); |
| resolveExp(e, pt, pe, ps); |
| } |
| if (pt) |
| pt = pt.addMod(mt.mod); |
| } |
| mt.inuse--; |
| } |
| |
| void visitReturn(TypeReturn mt) |
| { |
| //printf("TypeReturn::resolve(sc = %p, idents = '%s')\n", sc, mt.toChars()); |
| Type t; |
| { |
| FuncDeclaration func = sc.func; |
| if (!func) |
| { |
| error(loc, "`typeof(return)` must be inside function"); |
| return returnError(); |
| } |
| if (func.fes) |
| func = func.fes.func; |
| t = func.type.nextOf(); |
| if (!t) |
| { |
| error(loc, "cannot use `typeof(return)` inside function `%s` with inferred return type", sc.func.toChars()); |
| return returnError(); |
| } |
| } |
| if (mt.idents.length == 0) |
| { |
| return returnType(t.addMod(mt.mod)); |
| } |
| else |
| { |
| if (Dsymbol s = t.toDsymbol(sc)) |
| mt.resolveHelper(loc, sc, s, null, pe, pt, ps, intypeid); |
| else |
| { |
| auto e = typeToExpressionHelper(mt, new TypeExp(loc, t)); |
| e = e.expressionSemantic(sc); |
| resolveExp(e, pt, pe, ps); |
| } |
| if (pt) |
| pt = pt.addMod(mt.mod); |
| } |
| } |
| |
| void visitSlice(TypeSlice mt) |
| { |
| mt.next.resolve(loc, sc, pe, pt, ps, intypeid); |
| if (pe) |
| { |
| // It's really a slice expression |
| if (Dsymbol s = getDsymbol(pe)) |
| pe = new DsymbolExp(loc, s); |
| return returnExp(new ArrayExp(loc, pe, new IntervalExp(loc, mt.lwr, mt.upr))); |
| } |
| else if (ps) |
| { |
| Dsymbol s = ps; |
| TupleDeclaration td = s.isTupleDeclaration(); |
| if (td) |
| { |
| /* It's a slice of a TupleDeclaration |
| */ |
| ScopeDsymbol sym = new ArrayScopeSymbol(sc, td); |
| sym.parent = sc.scopesym; |
| sc = sc.push(sym); |
| sc = sc.startCTFE(); |
| mt.lwr = mt.lwr.expressionSemantic(sc); |
| mt.upr = mt.upr.expressionSemantic(sc); |
| sc = sc.endCTFE(); |
| sc = sc.pop(); |
| |
| mt.lwr = mt.lwr.ctfeInterpret(); |
| mt.upr = mt.upr.ctfeInterpret(); |
| const i1 = mt.lwr.toUInteger(); |
| const i2 = mt.upr.toUInteger(); |
| if (!(i1 <= i2 && i2 <= td.objects.length)) |
| { |
| error(loc, "slice `[%llu..%llu]` is out of range of [0..%llu]", i1, i2, cast(ulong) td.objects.length); |
| return returnError(); |
| } |
| |
| if (i1 == 0 && i2 == td.objects.length) |
| { |
| return returnSymbol(td); |
| } |
| |
| /* Create a new TupleDeclaration which |
| * is a slice [i1..i2] out of the old one. |
| */ |
| auto objects = new Objects(cast(size_t)(i2 - i1)); |
| for (size_t i = 0; i < objects.length; i++) |
| { |
| (*objects)[i] = (*td.objects)[cast(size_t)i1 + i]; |
| } |
| |
| return returnSymbol(new TupleDeclaration(loc, td.ident, objects)); |
| } |
| else |
| visitType(mt); |
| } |
| else |
| { |
| if (pt.ty != Terror) |
| mt.next = pt; // prevent re-running semantic() on 'next' |
| visitType(mt); |
| } |
| } |
| |
| void visitMixin(TypeMixin mt) |
| { |
| RootObject o = mt.obj; |
| |
| // if already resolved just set pe/pt/ps and return. |
| if (o) |
| { |
| pe = o.isExpression(); |
| pt = o.isType(); |
| ps = o.isDsymbol(); |
| return; |
| } |
| |
| o = mt.compileTypeMixin(loc, sc); |
| if (auto t = o.isType()) |
| { |
| resolve(t, loc, sc, pe, pt, ps, intypeid); |
| if (pt) |
| pt = pt.addMod(mt.mod); |
| } |
| else if (auto e = o.isExpression()) |
| { |
| e = e.expressionSemantic(sc); |
| if (auto et = e.isTypeExp()) |
| returnType(et.type.addMod(mt.mod)); |
| else |
| returnExp(e); |
| } |
| else |
| returnError(); |
| |
| // save the result |
| mt.obj = pe ? pe : (pt ? pt : ps); |
| } |
| |
| void visitTraits(TypeTraits mt) |
| { |
| // if already resolved just return the cached object. |
| if (mt.obj) |
| { |
| pt = mt.obj.isType(); |
| ps = mt.obj.isDsymbol(); |
| pe = mt.obj.isExpression(); |
| return; |
| } |
| |
| import dmd.traits : semanticTraits; |
| |
| if (Expression e = semanticTraits(mt.exp, sc)) |
| { |
| switch (e.op) |
| { |
| case EXP.dotVariable: |
| mt.obj = e.isDotVarExp().var; |
| break; |
| case EXP.variable: |
| mt.obj = e.isVarExp().var; |
| break; |
| case EXP.function_: |
| auto fe = e.isFuncExp(); |
| mt.obj = fe.td ? fe.td : fe.fd; |
| break; |
| case EXP.dotTemplateDeclaration: |
| mt.obj = e.isDotTemplateExp().td; |
| break; |
| case EXP.dSymbol: |
| mt.obj = e.isDsymbolExp().s; |
| break; |
| case EXP.template_: |
| mt.obj = e.isTemplateExp().td; |
| break; |
| case EXP.scope_: |
| mt.obj = e.isScopeExp().sds; |
| break; |
| case EXP.tuple: |
| TupleExp te = e.isTupleExp(); |
| Objects* elems = new Objects(te.exps.length); |
| foreach (i; 0 .. elems.length) |
| { |
| auto src = (*te.exps)[i]; |
| switch (src.op) |
| { |
| case EXP.type: |
| (*elems)[i] = src.isTypeExp().type; |
| break; |
| case EXP.dotType: |
| (*elems)[i] = src.isDotTypeExp().sym.isType(); |
| break; |
| case EXP.overloadSet: |
| (*elems)[i] = src.isOverExp().type; |
| break; |
| default: |
| if (auto sym = isDsymbol(src)) |
| (*elems)[i] = sym; |
| else |
| (*elems)[i] = src; |
| } |
| } |
| TupleDeclaration td = new TupleDeclaration(e.loc, Identifier.generateId("__aliastup"), elems); |
| mt.obj = td; |
| break; |
| case EXP.dotType: |
| mt.obj = e.isDotTypeExp().sym.isType(); |
| break; |
| case EXP.type: |
| mt.obj = e.isTypeExp().type; |
| break; |
| case EXP.overloadSet: |
| mt.obj = e.isOverExp().type; |
| break; |
| case EXP.error: |
| break; |
| default: |
| mt.obj = e; |
| break; |
| } |
| } |
| |
| if (mt.obj) |
| { |
| if (auto t = mt.obj.isType()) |
| { |
| t = t.addMod(mt.mod); |
| mt.obj = t; |
| returnType(t); |
| } |
| else if (auto s = mt.obj.isDsymbol()) |
| returnSymbol(s); |
| else if (auto e = mt.obj.isExpression()) |
| returnExp(e); |
| } |
| else |
| { |
| assert(global.errors); |
| mt.obj = Type.terror; |
| return returnError(); |
| } |
| } |
| |
| switch (mt.ty) |
| { |
| default: visitType (mt); break; |
| case Tsarray: visitSArray (mt.isTypeSArray()); break; |
| case Tarray: visitDArray (mt.isTypeDArray()); break; |
| case Taarray: visitAArray (mt.isTypeAArray()); break; |
| case Tident: visitIdentifier(mt.isTypeIdentifier()); break; |
| case Tinstance: visitInstance (mt.isTypeInstance()); break; |
| case Ttypeof: visitTypeof (mt.isTypeTypeof()); break; |
| case Treturn: visitReturn (mt.isTypeReturn()); break; |
| case Tslice: visitSlice (mt.isTypeSlice()); break; |
| case Tmixin: visitMixin (mt.isTypeMixin()); break; |
| case Ttraits: visitTraits (mt.isTypeTraits()); break; |
| } |
| } |
| |
| /************************ |
| * Access the members of the object e. This type is same as e.type. |
| * Params: |
| * mt = type for which the dot expression is used |
| * sc = instantiating scope |
| * e = expression to convert |
| * ident = identifier being used |
| * flag = DotExpFlag bit flags |
| * |
| * Returns: |
| * resulting expression with e.ident resolved |
| */ |
| Expression dotExp(Type mt, Scope* sc, Expression e, Identifier ident, int flag) |
| { |
| Expression visitType(Type mt) |
| { |
| VarDeclaration v = null; |
| static if (LOGDOTEXP) |
| { |
| printf("Type::dotExp(e = '%s', ident = '%s')\n", e.toChars(), ident.toChars()); |
| } |
| Expression ex = e.lastComma(); |
| if (ex.op == EXP.dotVariable) |
| { |
| DotVarExp dv = cast(DotVarExp)ex; |
| v = dv.var.isVarDeclaration(); |
| } |
| else if (ex.op == EXP.variable) |
| { |
| VarExp ve = cast(VarExp)ex; |
| v = ve.var.isVarDeclaration(); |
| } |
| if (v) |
| { |
| if (ident == Id.offsetof) |
| { |
| v.dsymbolSemantic(null); |
| if (v.isField()) |
| { |
| auto ad = v.isMember(); |
| objc.checkOffsetof(e, ad); |
| ad.size(e.loc); |
| if (ad.sizeok != Sizeok.done) |
| return ErrorExp.get(); |
| return new IntegerExp(e.loc, v.offset, Type.tsize_t); |
| } |
| } |
| else if (ident == Id._init) |
| { |
| Type tb = mt.toBasetype(); |
| e = mt.defaultInitLiteral(e.loc); |
| if (tb.ty == Tstruct && tb.needsNested()) |
| { |
| e.isStructLiteralExp().useStaticInit = true; |
| } |
| goto Lreturn; |
| } |
| } |
| if (ident == Id.stringof) |
| { |
| /* https://issues.dlang.org/show_bug.cgi?id=3796 |
| * this should demangle e.type.deco rather than |
| * pretty-printing the type. |
| */ |
| e = new StringExp(e.loc, e.toString()); |
| } |
| else |
| e = mt.getProperty(sc, e.loc, ident, flag & DotExpFlag.gag); |
| |
| Lreturn: |
| if (e) |
| e = e.expressionSemantic(sc); |
| return e; |
| } |
| |
| Expression visitError(TypeError) |
| { |
| return ErrorExp.get(); |
| } |
| |
| Expression visitBasic(TypeBasic mt) |
| { |
| static if (LOGDOTEXP) |
| { |
| printf("TypeBasic::dotExp(e = '%s', ident = '%s')\n", e.toChars(), ident.toChars()); |
| } |
| Type t; |
| if (ident == Id.re) |
| { |
| switch (mt.ty) |
| { |
| case Tcomplex32: |
| t = mt.tfloat32; |
| goto L1; |
| |
| case Tcomplex64: |
| t = mt.tfloat64; |
| goto L1; |
| |
| case Tcomplex80: |
| t = mt.tfloat80; |
| goto L1; |
| L1: |
| e = e.castTo(sc, t); |
| break; |
| |
| case Tfloat32: |
| case Tfloat64: |
| case Tfloat80: |
| break; |
| |
| case Timaginary32: |
| t = mt.tfloat32; |
| goto L2; |
| |
| case Timaginary64: |
| t = mt.tfloat64; |
| goto L2; |
| |
| case Timaginary80: |
| t = mt.tfloat80; |
| goto L2; |
| L2: |
| e = new RealExp(e.loc, CTFloat.zero, t); |
| break; |
| |
| default: |
| e = mt.Type.getProperty(sc, e.loc, ident, flag); |
| break; |
| } |
| } |
| else if (ident == Id.im) |
| { |
| Type t2; |
| switch (mt.ty) |
| { |
| case Tcomplex32: |
| t = mt.timaginary32; |
| t2 = mt.tfloat32; |
| goto L3; |
| |
| case Tcomplex64: |
| t = mt.timaginary64; |
| t2 = mt.tfloat64; |
| goto L3; |
| |
| case Tcomplex80: |
| t = mt.timaginary80; |
| t2 = mt.tfloat80; |
| goto L3; |
| L3: |
| e = e.castTo(sc, t); |
| e.type = t2; |
| break; |
| |
| case Timaginary32: |
| t = mt.tfloat32; |
| goto L4; |
| |
| case Timaginary64: |
| t = mt.tfloat64; |
| goto L4; |
| |
| case Timaginary80: |
| t = mt.tfloat80; |
| goto L4; |
| L4: |
| e = e.copy(); |
| e.type = t; |
| break; |
| |
| case Tfloat32: |
| case Tfloat64: |
| case Tfloat80: |
| e = new RealExp(e.loc, CTFloat.zero, mt); |
| break; |
| |
| default: |
| e = mt.Type.getProperty(sc, e.loc, ident, flag); |
| break; |
| } |
| } |
| else |
| { |
| return visitType(mt); |
| } |
| if (!(flag & 1) || e) |
| e = e.expressionSemantic(sc); |
| return e; |
| } |
| |
| Expression visitVector(TypeVector mt) |
| { |
| static if (LOGDOTEXP) |
| { |
| printf("TypeVector::dotExp(e = '%s', ident = '%s')\n", e.toChars(), ident.toChars()); |
| } |
| if (ident == Id.ptr && e.op == EXP.call) |
| { |
| /* The trouble with EXP.call is the return ABI for float[4] is different from |
| * __vector(float[4]), and a type paint won't do. |
| */ |
| e = new AddrExp(e.loc, e); |
| e = e.expressionSemantic(sc); |
| return e.castTo(sc, mt.basetype.nextOf().pointerTo()); |
| } |
| if (ident == Id.array) |
| { |
| //e = e.castTo(sc, basetype); |
| // Keep lvalue-ness |
| e = new VectorArrayExp(e.loc, e); |
| e = e.expressionSemantic(sc); |
| return e; |
| } |
| if (ident == Id._init || ident == Id.offsetof || ident == Id.stringof || ident == Id.__xalignof) |
| { |
| // init should return a new VectorExp |
| // https://issues.dlang.org/show_bug.cgi?id=12776 |
| // offsetof does not work on a cast expression, so use e directly |
| // stringof should not add a cast to the output |
| return visitType(mt); |
| } |
| |
| // Properties based on the vector element type and are values of the element type |
| if (ident == Id.max || ident == Id.min || ident == Id.min_normal || |
| ident == Id.nan || ident == Id.infinity || ident == Id.epsilon) |
| { |
| auto vet = mt.basetype.isTypeSArray().next; // vector element type |
| if (auto ev = getProperty(vet, sc, e.loc, ident, DotExpFlag.gag)) |
| return ev.castTo(sc, mt); // 'broadcast' ev to the vector elements |
| } |
| |
| return mt.basetype.dotExp(sc, e.castTo(sc, mt.basetype), ident, flag); |
| } |
| |
| Expression visitArray(TypeArray mt) |
| { |
| static if (LOGDOTEXP) |
| { |
| printf("TypeArray::dotExp(e = '%s', ident = '%s')\n", e.toChars(), ident.toChars()); |
| } |
| |
| e = visitType(mt); |
| |
| if (!(flag & 1) || e) |
| e = e.expressionSemantic(sc); |
| return e; |
| } |
| |
| Expression visitSArray(TypeSArray mt) |
| { |
| static if (LOGDOTEXP) |
| { |
| printf("TypeSArray::dotExp(e = '%s', ident = '%s')\n", e.toChars(), ident.toChars()); |
| } |
| if (ident == Id.length) |
| { |
| Loc oldLoc = e.loc; |
| e = mt.dim.copy(); |
| e.loc = oldLoc; |
| } |
| else if (ident == Id.ptr) |
| { |
| if (e.op == EXP.type) |
| { |
| e.error("`%s` is not an expression", e.toChars()); |
| return ErrorExp.get(); |
| } |
| else if (mt.dim.toUInteger() < 1 && checkUnsafeDotExp(sc, e, ident, flag)) |
| { |
| // .ptr on static array is @safe unless size is 0 |
| // https://issues.dlang.org/show_bug.cgi?id=20853 |
| return ErrorExp.get(); |
| } |
| e = e.castTo(sc, e.type.nextOf().pointerTo()); |
| } |
| else if (ident == Id._tupleof) |
| { |
| if (e.isTypeExp()) |
| { |
| e.error("`.tupleof` cannot be used on type `%s`", mt.toChars); |
| return ErrorExp.get(); |
| } |
| else |
| { |
| Expression e0; |
| Expression ev = e; |
| ev = extractSideEffect(sc, "__tup", e0, ev); |
| |
| const length = cast(size_t)mt.dim.toUInteger(); |
| auto exps = new Expressions(); |
| exps.reserve(length); |
| foreach (i; 0 .. length) |
| exps.push(new IndexExp(e.loc, ev, new IntegerExp(e.loc, i, Type.tsize_t))); |
| e = new TupleExp(e.loc, e0, exps); |
| } |
| } |
| else |
| { |
| e = visitArray(mt); |
| } |
| if (!(flag & 1) || e) |
| e = e.expressionSemantic(sc); |
| return e; |
| } |
| |
| Expression visitDArray(TypeDArray mt) |
| { |
| static if (LOGDOTEXP) |
| { |
| printf("TypeDArray::dotExp(e = '%s', ident = '%s')\n", e.toChars(), ident.toChars()); |
| } |
| if (e.op == EXP.type && (ident == Id.length || ident == Id.ptr)) |
| { |
| e.error("`%s` is not an expression", e.toChars()); |
| return ErrorExp.get(); |
| } |
| if (ident == Id.length) |
| { |
| if (e.op == EXP.string_) |
| { |
| StringExp se = cast(StringExp)e; |
| return new IntegerExp(se.loc, se.len, Type.tsize_t); |
| } |
| if (e.op == EXP.null_) |
| { |
| return new IntegerExp(e.loc, 0, Type.tsize_t); |
| } |
| if (checkNonAssignmentArrayOp(e)) |
| { |
| return ErrorExp.get(); |
| } |
| e = new ArrayLengthExp(e.loc, e); |
| e.type = Type.tsize_t; |
| return e; |
| } |
| else if (ident == Id.ptr) |
| { |
| if (checkUnsafeDotExp(sc, e, ident, flag)) |
| return ErrorExp.get(); |
| return e.castTo(sc, mt.next.pointerTo()); |
| } |
| else |
| { |
| return visitArray(mt); |
| } |
| } |
| |
| Expression visitAArray(TypeAArray mt) |
| { |
| static if (LOGDOTEXP) |
| { |
| printf("TypeAArray::dotExp(e = '%s', ident = '%s')\n", e.toChars(), ident.toChars()); |
| } |
| if (ident == Id.length) |
| { |
| __gshared FuncDeclaration fd_aaLen = null; |
| if (fd_aaLen is null) |
| { |
| auto fparams = new Parameters(); |
| fparams.push(new Parameter(STC.const_ | STC.scope_, mt, null, null, null)); |
| fd_aaLen = FuncDeclaration.genCfunc(fparams, Type.tsize_t, Id.aaLen); |
| TypeFunction tf = fd_aaLen.type.toTypeFunction(); |
| tf.purity = PURE.const_; |
| tf.isnothrow = true; |
| tf.isnogc = false; |
| } |
| Expression ev = new VarExp(e.loc, fd_aaLen, false); |
| e = new CallExp(e.loc, ev, e); |
| e.type = fd_aaLen.type.toTypeFunction().next; |
| return e; |
| } |
| else |
| { |
| return visitType(mt); |
| } |
| } |
| |
| Expression visitReference(TypeReference mt) |
| { |
| static if (LOGDOTEXP) |
| { |
| printf("TypeReference::dotExp(e = '%s', ident = '%s')\n", e.toChars(), ident.toChars()); |
| } |
| // References just forward things along |
| return mt.next.dotExp(sc, e, ident, flag); |
| } |
| |
| Expression visitDelegate(TypeDelegate mt) |
| { |
| static if (LOGDOTEXP) |
| { |
| printf("TypeDelegate::dotExp(e = '%s', ident = '%s')\n", e.toChars(), ident.toChars()); |
| } |
| if (ident == Id.ptr) |
| { |
| e = new DelegatePtrExp(e.loc, e); |
| e = e.expressionSemantic(sc); |
| } |
| else if (ident == Id.funcptr) |
| { |
| if (checkUnsafeDotExp(sc, e, ident, flag)) |
| { |
| return ErrorExp.get(); |
| } |
| e = new DelegateFuncptrExp(e.loc, e); |
| e = e.expressionSemantic(sc); |
| } |
| else |
| { |
| return visitType(mt); |
| } |
| return e; |
| } |
| |
| /*************************************** |
| * `ident` was not found as a member of `mt`. |
| * Attempt to use overloaded opDot(), overloaded opDispatch(), or `alias this`. |
| * If that fails, forward to visitType(). |
| * Params: |
| * mt = class or struct |
| * sc = context |
| * e = `this` for `ident` |
| * ident = name of member |
| * flag = flag & 1, don't report "not a property" error and just return NULL. |
| * flag & DotExpFlag.noAliasThis, don't do 'alias this' resolution. |
| * Returns: |
| * resolved expression if found, otherwise null |
| */ |
| Expression noMember(Type mt, Scope* sc, Expression e, Identifier ident, int flag) |
| { |
| //printf("Type.noMember(e: %s ident: %s flag: %d)\n", e.toChars(), ident.toChars(), flag); |
| |
| bool gagError = flag & 1; |
| |
| __gshared int nest; // https://issues.dlang.org/show_bug.cgi?id=17380 |
| |
| static Expression returnExp(Expression e) |
| { |
| --nest; |
| return e; |
| } |
| |
| if (++nest > global.recursionLimit) |
| { |
| .error(e.loc, "cannot resolve identifier `%s`", ident.toChars()); |
| return returnExp(gagError ? null : ErrorExp.get()); |
| } |
| |
| |
| assert(mt.ty == Tstruct || mt.ty == Tclass); |
| auto sym = mt.toDsymbol(sc).isAggregateDeclaration(); |
| assert(sym); |
| if (// https://issues.dlang.org/show_bug.cgi?id=22054 |
| // if a class or struct does not have a body |
| // there is no point in searching for its members |
| sym.members && |
| ident != Id.__sizeof && |
| ident != Id.__xalignof && |
| ident != Id._init && |
| ident != Id._mangleof && |
| ident != Id.stringof && |
| ident != Id.offsetof && |
| // https://issues.dlang.org/show_bug.cgi?id=15045 |
| // Don't forward special built-in member functions. |
| ident != Id.ctor && |
| ident != Id.dtor && |
| ident != Id.__xdtor && |
| ident != Id.postblit && |
| ident != Id.__xpostblit) |
| { |
| /* Look for overloaded opDot() to see if we should forward request |
| * to it. |
| */ |
| if (auto fd = search_function(sym, Id.opDot)) |
| { |
| /* Rewrite e.ident as: |
| * e.opDot().ident |
| */ |
| e = build_overload(e.loc, sc, e, null, fd); |
| // @@@DEPRECATED_2.110@@@. |
| // Deprecated in 2.082, made an error in 2.100. |
| e.error("`opDot` is obsolete. Use `alias this`"); |
| return ErrorExp.get(); |
| } |
| |
| /* Look for overloaded opDispatch to see if we should forward request |
| * to it. |
| */ |
| if (auto fd = search_function(sym, Id.opDispatch)) |
| { |
| /* Rewrite e.ident as: |
| * e.opDispatch!("ident") |
| */ |
| TemplateDeclaration td = fd.isTemplateDeclaration(); |
| if (!td) |
| { |
| fd.error("must be a template `opDispatch(string s)`, not a %s", fd.kind()); |
| return returnExp(ErrorExp.get()); |
| } |
| auto se = new StringExp(e.loc, ident.toString()); |
| auto tiargs = new Objects(); |
| tiargs.push(se); |
| auto dti = new DotTemplateInstanceExp(e.loc, e, Id.opDispatch, tiargs); |
| dti.ti.tempdecl = td; |
| /* opDispatch, which doesn't need IFTI, may occur instantiate error. |
| * e.g. |
| * template opDispatch(name) if (isValid!name) { ... } |
| */ |
| uint errors = gagError ? global.startGagging() : 0; |
| e = dti.dotTemplateSemanticProp(sc, 0); |
| if (gagError && global.endGagging(errors)) |
| e = null; |
| return returnExp(e); |
| } |
| |
| /* See if we should forward to the alias this. |
| */ |
| auto alias_e = flag & DotExpFlag.noAliasThis ? null |
| : resolveAliasThis(sc, e, gagError); |
| if (alias_e && alias_e != e) |
| { |
| /* Rewrite e.ident as: |
| * e.aliasthis.ident |
| */ |
| auto die = new DotIdExp(e.loc, alias_e, ident); |
| |
| auto errors = gagError ? 0 : global.startGagging(); |
| auto exp = die.dotIdSemanticProp(sc, gagError); |
| if (!gagError) |
| { |
| global.endGagging(errors); |
| if (exp && exp.op == EXP.error) |
| exp = null; |
| } |
| |
| if (exp && gagError) |
| // now that we know that the alias this leads somewhere useful, |
| // go back and print deprecations/warnings that we skipped earlier due to the gag |
| resolveAliasThis(sc, e, false); |
| |
| return returnExp(exp); |
| } |
| } |
| return returnExp(visitType(mt)); |
| } |
| |
| Expression visitStruct(TypeStruct mt) |
| { |
| Dsymbol s; |
| static if (LOGDOTEXP) |
| { |
| printf("TypeStruct::dotExp(e = '%s', ident = '%s')\n", e.toChars(), ident.toChars()); |
| } |
| assert(e.op != EXP.dot); |
| |
| // https://issues.dlang.org/show_bug.cgi?id=14010 |
| if (!(sc.flags & SCOPE.Cfile) && ident == Id._mangleof) |
| { |
| return mt.getProperty(sc, e.loc, ident, flag & 1); |
| } |
| |
| /* If e.tupleof |
| */ |
| if (ident == Id._tupleof) |
| { |
| /* Create a TupleExp out of the fields of the struct e: |
| * (e.field0, e.field1, e.field2, ...) |
| */ |
| e = e.expressionSemantic(sc); // do this before turning on noaccesscheck |
| |
| if (!mt.sym.determineFields()) |
| { |
| error(e.loc, "unable to determine fields of `%s` because of forward references", mt.toChars()); |
| } |
| |
| Expression e0; |
| Expression ev = e.op == EXP.type ? null : e; |
| if (ev) |
| ev = extractSideEffect(sc, "__tup", e0, ev); |
| |
| auto exps = new Expressions(); |
| exps.reserve(mt.sym.fields.length); |
| for (size_t i = 0; i < mt.sym.fields.length; i++) |
| { |
| VarDeclaration v = mt.sym.fields[i]; |
| Expression ex; |
| if (ev) |
| ex = new DotVarExp(e.loc, ev, v); |
| else |
| { |
| ex = new VarExp(e.loc, v); |
| ex.type = ex.type.addMod(e.type.mod); |
| } |
| exps.push(ex); |
| } |
| |
| e = new TupleExp(e.loc, e0, exps); |
| Scope* sc2 = sc.push(); |
| sc2.flags |= SCOPE.noaccesscheck; |
| e = e.expressionSemantic(sc2); |
| sc2.pop(); |
| return e; |
| } |
| |
| immutable flags = sc.flags & SCOPE.ignoresymbolvisibility ? IgnoreSymbolVisibility : 0; |
| s = mt.sym.search(e.loc, ident, flags | IgnorePrivateImports); |
| L1: |
| if (!s) |
| { |
| return noMember(mt, sc, e, ident, flag); |
| } |
| if (!(sc.flags & SCOPE.ignoresymbolvisibility) && !symbolIsVisible(sc, s)) |
| { |
| return noMember(mt, sc, e, ident, flag); |
| } |
| s = s.toAlias(); |
| |
| if (auto em = s.isEnumMember()) |
| { |
| return em.getVarExp(e.loc, sc); |
| } |
| if (auto v = s.isVarDeclaration()) |
| { |
| v.checkDeprecated(e.loc, sc); |
| v.checkDisabled(e.loc, sc); |
| if (!v.type || |
| !v.type.deco && v.inuse) |
| { |
| if (v.inuse) // https://issues.dlang.org/show_bug.cgi?id=9494 |
| e.error("circular reference to %s `%s`", v.kind(), v.toPrettyChars()); |
| else |
| e.error("forward reference to %s `%s`", v.kind(), v.toPrettyChars()); |
| return ErrorExp.get(); |
| } |
| if (v.type.ty == Terror) |
| { |
| return ErrorExp.get(); |
| } |
| |
| if ((v.storage_class & STC.manifest) && v._init) |
| { |
| if (v.inuse) |
| { |
| e.error("circular initialization of %s `%s`", v.kind(), v.toPrettyChars()); |
| return ErrorExp.get(); |
| } |
| checkAccess(e.loc, sc, null, v); |
| Expression ve = new VarExp(e.loc, v); |
| if (!isTrivialExp(e)) |
| { |
| ve = new CommaExp(e.loc, e, ve); |
| } |
| return ve.expressionSemantic(sc); |
| } |
| } |
| |
| if (auto t = s.getType()) |
| { |
| return (new TypeExp(e.loc, t)).expressionSemantic(sc); |
| } |
| |
| TemplateMixin tm = s.isTemplateMixin(); |
| if (tm) |
| { |
| return new DotExp(e.loc, e, new ScopeExp(e.loc, tm)).expressionSemantic(sc); |
| } |
| |
| TemplateDeclaration td = s.isTemplateDeclaration(); |
| if (td) |
| { |
| if (e.op == EXP.type) |
| e = new TemplateExp(e.loc, td); |
| else |
| e = new DotTemplateExp(e.loc, e, td); |
| return e.expressionSemantic(sc); |
| } |
| |
| TemplateInstance ti = s.isTemplateInstance(); |
| if (ti) |
| { |
| if (!ti.semanticRun) |
| { |
| ti.dsymbolSemantic(sc); |
| if (!ti.inst || ti.errors) // if template failed to expand |
| { |
| return ErrorExp.get(); |
| } |
| } |
| s = ti.inst.toAlias(); |
| if (!s.isTemplateInstance()) |
| goto L1; |
| if (e.op == EXP.type) |
| e = new ScopeExp(e.loc, ti); |
| else |
| e = new DotExp(e.loc, e, new ScopeExp(e.loc, ti)); |
| return e.expressionSemantic(sc); |
| } |
| |
| if (s.isImport() || s.isModule() || s.isPackage()) |
| { |
| return symbolToExp(s, e.loc, sc, false); |
| } |
| |
| OverloadSet o = s.isOverloadSet(); |
| if (o) |
| { |
| auto oe = new OverExp(e.loc, o); |
| if (e.op == EXP.type) |
| { |
| return oe; |
| } |
| return new DotExp(e.loc, e, oe); |
| } |
| |
| Declaration d = s.isDeclaration(); |
| if (!d) |
| { |
| e.error("`%s.%s` is not a declaration", e.toChars(), ident.toChars()); |
| return ErrorExp.get(); |
| } |
| |
| if (e.op == EXP.type) |
| { |
| /* It's: |
| * Struct.d |
| */ |
| if (TupleDeclaration tup = d.isTupleDeclaration()) |
| { |
| e = new TupleExp(e.loc, tup); |
| return e.expressionSemantic(sc); |
| } |
| if (d.needThis() && sc.intypeof != 1) |
| { |
| /* Rewrite as: |
| * this.d |
| * |
| * only if the scope in which we are |
| * has a `this` that matches the type |
| * of the lhs of the dot expression. |
| * |
| * https://issues.dlang.org/show_bug.cgi?id=23617 |
| */ |
| auto fd = hasThis(sc); |
| if (fd && fd.isThis() == mt.sym) |
| { |
| e = new DotVarExp(e.loc, new ThisExp(e.loc), d); |
| return e.expressionSemantic(sc); |
| } |
| } |
| if (d.semanticRun == PASS.initial) |
| d.dsymbolSemantic(null); |
| checkAccess(e.loc, sc, e, d); |
| auto ve = new VarExp(e.loc, d); |
| if (d.isVarDeclaration() && d.needThis()) |
| ve.type = d.type.addMod(e.type.mod); |
| return ve; |
| } |
| |
| bool unreal = e.op == EXP.variable && (cast(VarExp)e).var.isField(); |
| if (d.isDataseg() || unreal && d.isField()) |
| { |
| // (e, d) |
| checkAccess(e.loc, sc, e, d); |
| Expression ve = new VarExp(e.loc, d); |
| e = unreal ? ve : new CommaExp(e.loc, e, ve); |
| return e.expressionSemantic(sc); |
| } |
| |
| e = new DotVarExp(e.loc, e, d); |
| return e.expressionSemantic(sc); |
| } |
| |
| Expression visitEnum(TypeEnum mt) |
| { |
| static if (LOGDOTEXP) |
| { |
| printf("TypeEnum::dotExp(e = '%s', ident = '%s') '%s'\n", e.toChars(), ident.toChars(), mt.toChars()); |
| } |
| // https://issues.dlang.org/show_bug.cgi?id=14010 |
| if (ident == Id._mangleof) |
| { |
| return mt.getProperty(sc, e.loc, ident, flag & 1); |
| } |
| |
| if (mt.sym.semanticRun < PASS.semanticdone) |
| mt.sym.dsymbolSemantic(null); |
| |
| Dsymbol s = mt.sym.search(e.loc, ident); |
| if (!s) |
| { |
| if (ident == Id._init) |
| { |
| return mt.getProperty(sc, e.loc, ident, flag & 1); |
| } |
| |
| /* Allow special enums to not need a member list |
| */ |
| if ((ident == Id.max || ident == Id.min) && (mt.sym.members || !mt.sym.isSpecial())) |
| { |
| return mt.getProperty(sc, e.loc, ident, flag & 1); |
| } |
| |
| Expression res = mt.sym.getMemtype(Loc.initial).dotExp(sc, e, ident, 1); |
| if (!(flag & 1) && !res) |
| { |
| if (auto ns = mt.sym.search_correct(ident)) |
| e.error("no property `%s` for type `%s`. Did you mean `%s.%s` ?", ident.toChars(), mt.toChars(), mt.toChars(), |
| ns.toChars()); |
| else |
| e.error("no property `%s` for type `%s`", ident.toChars(), |
| mt.toChars()); |
| |
| return ErrorExp.get(); |
| } |
| return res; |
| } |
| EnumMember m = s.isEnumMember(); |
| return m.getVarExp(e.loc, sc); |
| } |
| |
| Expression visitClass(TypeClass mt) |
| { |
| Dsymbol s; |
| static if (LOGDOTEXP) |
| { |
| printf("TypeClass::dotExp(e = '%s', ident = '%s')\n", e.toChars(), ident.toChars()); |
| } |
| assert(e.op != EXP.dot); |
| |
| // https://issues.dlang.org/show_bug.cgi?id=12543 |
| if (ident == Id.__sizeof || ident == Id.__xalignof || ident == Id._mangleof) |
| { |
| return mt.Type.getProperty(sc, e.loc, ident, 0); |
| } |
| |
| /* If e.tupleof |
| */ |
| if (ident == Id._tupleof) |
| { |
| objc.checkTupleof(e, mt); |
| |
| /* Create a TupleExp |
| */ |
| e = e.expressionSemantic(sc); // do this before turning on noaccesscheck |
| |
| mt.sym.size(e.loc); // do semantic of type |
| |
| Expression e0; |
| Expression ev = e.op == EXP.type ? null : e; |
| if (ev) |
| ev = extractSideEffect(sc, "__tup", e0, ev); |
| |
| auto exps = new Expressions(); |
| exps.reserve(mt.sym.fields.length); |
| for (size_t i = 0; i < mt.sym.fields.length; i++) |
| { |
| VarDeclaration v = mt.sym.fields[i]; |
| // Don't include hidden 'this' pointer |
| if (v.isThisDeclaration()) |
| continue; |
| Expression ex; |
| if (ev) |
| ex = new DotVarExp(e.loc, ev, v); |
| else |
| { |
| ex = new VarExp(e.loc, v); |
| ex.type = ex.type.addMod(e.type.mod); |
| } |
| exps.push(ex); |
| } |
| |
| e = new TupleExp(e.loc, e0, exps); |
| Scope* sc2 = sc.push(); |
| sc2.flags |= SCOPE.noaccesscheck; |
| e = e.expressionSemantic(sc2); |
| sc2.pop(); |
| return e; |
| } |
| |
| int flags = sc.flags & SCOPE.ignoresymbolvisibility ? IgnoreSymbolVisibility : 0; |
| s = mt.sym.search(e.loc, ident, flags | IgnorePrivateImports); |
| |
| L1: |
| if (!s) |
| { |
| // See if it's a 'this' class or a base class |
| if (mt.sym.ident == ident) |
| { |
| if (e.op == EXP.type) |
| { |
| return mt.Type.getProperty(sc, e.loc, ident, 0); |
| } |
| e = new DotTypeExp(e.loc, e, mt.sym); |
| e = e.expressionSemantic(sc); |
| return e; |
| } |
| if (auto cbase = mt.sym.searchBase(ident)) |
| { |
| if (e.op == EXP.type) |
| { |
| return mt.Type.getProperty(sc, e.loc, ident, 0); |
| } |
| if (auto ifbase = cbase.isInterfaceDeclaration()) |
| e = new CastExp(e.loc, e, ifbase.type); |
| else |
| e = new DotTypeExp(e.loc, e, cbase); |
| e = e.expressionSemantic(sc); |
| return e; |
| } |
| |
| if (ident == Id.classinfo) |
| { |
| if (!Type.typeinfoclass) |
| { |
| error(e.loc, "`object.TypeInfo_Class` could not be found, but is implicitly used"); |
| return ErrorExp.get(); |
| } |
| |
| Type t = Type.typeinfoclass.type; |
| if (e.op == EXP.type || e.op == EXP.dotType) |
| { |
| /* For type.classinfo, we know the classinfo |
| * at compile time. |
| */ |
| if (!mt.sym.vclassinfo) |
| mt.sym.vclassinfo = new TypeInfoClassDeclaration(mt.sym.type); |
| e = new VarExp(e.loc, mt.sym.vclassinfo); |
| e = e.addressOf(); |
| e.type = t; // do this so we don't get redundant dereference |
| } |
| else |
| { |
| /* For class objects, the classinfo reference is the first |
| * entry in the vtbl[] |
| */ |
| e = new PtrExp(e.loc, e); |
| e.type = t.pointerTo(); |
| if (mt.sym.isInterfaceDeclaration()) |
| { |
| if (mt.sym.isCPPinterface()) |
| { |
| /* C++ interface vtbl[]s are different in that the |
| * first entry is always pointer to the first virtual |
| * function, not classinfo. |
| * We can't get a .classinfo for it. |
| */ |
| error(e.loc, "no `.classinfo` for C++ interface objects"); |
| } |
| /* For an interface, the first entry in the vtbl[] |
| * is actually a pointer to an instance of struct Interface. |
| * The first member of Interface is the .classinfo, |
| * so add an extra pointer indirection. |
| */ |
| e.type = e.type.pointerTo(); |
| e = new PtrExp(e.loc, e); |
| e.type = t.pointerTo(); |
| } |
| e = new PtrExp(e.loc, e, t); |
| } |
| return e; |
| } |
| |
| if (ident == Id.__vptr) |
| { |
| /* The pointer to the vtbl[] |
| * *cast(immutable(void*)**)e |
| */ |
| e = e.castTo(sc, mt.tvoidptr.immutableOf().pointerTo().pointerTo()); |
| e = new PtrExp(e.loc, e); |
| e = e.expressionSemantic(sc); |
| return e; |
| } |
| |
| if (ident == Id.__monitor && mt.sym.hasMonitor()) |
| { |
| /* The handle to the monitor (call it a void*) |
| * *(cast(void**)e + 1) |
| */ |
| e = e.castTo(sc, mt.tvoidptr.pointerTo()); |
| e = new AddExp(e.loc, e, IntegerExp.literal!1); |
| e = new PtrExp(e.loc, e); |
| e = e.expressionSemantic(sc); |
| return e; |
| } |
| |
| if (ident == Id.outer && mt.sym.vthis) |
| { |
| if (mt.sym.vthis.semanticRun == PASS.initial) |
| mt.sym.vthis.dsymbolSemantic(null); |
| |
| if (auto cdp = mt.sym.toParentLocal().isClassDeclaration()) |
| { |
| auto dve = new DotVarExp(e.loc, e, mt.sym.vthis); |
| dve.type = cdp.type.addMod(e.type.mod); |
| return dve; |
| } |
| |
| /* https://issues.dlang.org/show_bug.cgi?id=15839 |
| * Find closest parent class through nested functions. |
| */ |
| for (auto p = mt.sym.toParentLocal(); p; p = p.toParentLocal()) |
| { |
| auto fd = p.isFuncDeclaration(); |
| if (!fd) |
| break; |
| auto ad = fd.isThis(); |
| if (!ad && fd.isNested()) |
| continue; |
| if (!ad) |
| break; |
| if (auto cdp = ad.isClassDeclaration()) |
| { |
| auto ve = new ThisExp(e.loc); |
| |
| ve.var = fd.vthis; |
| const nestedError = fd.vthis.checkNestedReference(sc, e.loc); |
| assert(!nestedError); |
| |
| ve.type = cdp.type.addMod(fd.vthis.type.mod).addMod(e.type.mod); |
| return ve; |
| } |
| break; |
| } |
| |
| // Continue to show enclosing function's frame (stack or closure). |
| auto dve = new DotVarExp(e.loc, e, mt.sym.vthis); |
| dve.type = mt.sym.vthis.type.addMod(e.type.mod); |
| return dve; |
| } |
| |
| return noMember(mt, sc, e, ident, flag & 1); |
| } |
| if (!(sc.flags & SCOPE.ignoresymbolvisibility) && !symbolIsVisible(sc, s)) |
| { |
| return noMember(mt, sc, e, ident, flag); |
| } |
| if (!s.isFuncDeclaration()) // because of overloading |
| { |
| s.checkDeprecated(e.loc, sc); |
| if (auto d = s.isDeclaration()) |
| d.checkDisabled(e.loc, sc); |
| } |
| s = s.toAlias(); |
| |
| if (auto em = s.isEnumMember()) |
| { |
| return em.getVarExp(e.loc, sc); |
| } |
| if (auto v = s.isVarDeclaration()) |
| { |
| if (!v.type || |
| !v.type.deco && v.inuse) |
| { |
| if (v.inuse) // https://issues.dlang.org/show_bug.cgi?id=9494 |
| e.error("circular reference to %s `%s`", v.kind(), v.toPrettyChars()); |
| else |
| e.error("forward reference to %s `%s`", v.kind(), v.toPrettyChars()); |
| return ErrorExp.get(); |
| } |
| if (v.type.ty == Terror) |
| { |
| e.error("type of variable `%s` has errors", v.toPrettyChars); |
| return ErrorExp.get(); |
| } |
| |
| if ((v.storage_class & STC.manifest) && v._init) |
| { |
| if (v.inuse) |
| { |
| e.error("circular initialization of %s `%s`", v.kind(), v.toPrettyChars()); |
| return ErrorExp.get(); |
| } |
| checkAccess(e.loc, sc, null, v); |
| Expression ve = new VarExp(e.loc, v); |
| ve = ve.expressionSemantic(sc); |
| return ve; |
| } |
| } |
| |
| if (auto t = s.getType()) |
| { |
| return (new TypeExp(e.loc, t)).expressionSemantic(sc); |
| } |
| |
| TemplateMixin tm = s.isTemplateMixin(); |
| if (tm) |
| { |
| return new DotExp(e.loc, e, new ScopeExp(e.loc, tm)).expressionSemantic(sc); |
| } |
| |
| TemplateDeclaration td = s.isTemplateDeclaration(); |
| |
| Expression toTemplateExp(TemplateDeclaration td) |
| { |
| if (e.op == EXP.type) |
| e = new TemplateExp(e.loc, td); |
| else |
| e = new DotTemplateExp(e.loc, e, td); |
| e = e.expressionSemantic(sc); |
| return e; |
| } |
| |
| if (td) |
| { |
| return toTemplateExp(td); |
| } |
| |
| TemplateInstance ti = s.isTemplateInstance(); |
| if (ti) |
| { |
| if (!ti.semanticRun) |
| { |
| ti.dsymbolSemantic(sc); |
| if (!ti.inst || ti.errors) // if template failed to expand |
| { |
| return ErrorExp.get(); |
| } |
| } |
| s = ti.inst.toAlias(); |
| if (!s.isTemplateInstance()) |
| goto L1; |
| if (e.op == EXP.type) |
| e = new ScopeExp(e.loc, ti); |
| else |
| e = new DotExp(e.loc, e, new ScopeExp(e.loc, ti)); |
| return e.expressionSemantic(sc); |
| } |
| |
| if (s.isImport() || s.isModule() || s.isPackage()) |
| { |
| e = symbolToExp(s, e.loc, sc, false); |
| return e; |
| } |
| |
| OverloadSet o = s.isOverloadSet(); |
| if (o) |
| { |
| auto oe = new OverExp(e.loc, o); |
| if (e.op == EXP.type) |
| { |
| return oe; |
| } |
| return new DotExp(e.loc, e, oe); |
| } |
| |
| Declaration d = s.isDeclaration(); |
| if (!d) |
| { |
| e.error("`%s.%s` is not a declaration", e.toChars(), ident.toChars()); |
| return ErrorExp.get(); |
| } |
| |
| if (e.op == EXP.type) |
| { |
| /* It's: |
| * Class.d |
| */ |
| if (TupleDeclaration tup = d.isTupleDeclaration()) |
| { |
| e = new TupleExp(e.loc, tup); |
| e = e.expressionSemantic(sc); |
| return e; |
| } |
| |
| if (mt.sym.classKind == ClassKind.objc |
| && d.isFuncDeclaration() |
| && d.isFuncDeclaration().isStatic |
| && d.isFuncDeclaration().objc.selector) |
| { |
| auto classRef = new ObjcClassReferenceExp(e.loc, mt.sym); |
| return new DotVarExp(e.loc, classRef, d).expressionSemantic(sc); |
| } |
| else if (d.needThis() && sc.intypeof != 1) |
| { |
| /* Rewrite as: |
| * this.d |
| */ |
| AggregateDeclaration ad = d.isMemberLocal(); |
| if (auto f = hasThis(sc)) |
| { |
| // This is almost same as getRightThis() in expressionsem.d |
| Expression e1; |
| Type t; |
| /* returns: true to continue, false to return */ |
| if (f.hasDualContext()) |
| { |
| if (f.followInstantiationContext(ad)) |
| { |
| e1 = new VarExp(e.loc, f.vthis); |
| e1 = new PtrExp(e1.loc, e1); |
| e1 = new IndexExp(e1.loc, e1, IntegerExp.literal!1); |
| auto pd = f.toParent2().isDeclaration(); |
| assert(pd); |
| t = pd.type.toBasetype(); |
| e1 = getThisSkipNestedFuncs(e1.loc, sc, f.toParent2(), ad, e1, t, d, true); |
| if (!e1) |
| { |
| e = new VarExp(e.loc, d); |
| return e; |
| } |
| goto L2; |
| } |
| } |
| e1 = new ThisExp(e.loc); |
| e1 = e1.expressionSemantic(sc); |
| L2: |
| t = e1.type.toBasetype(); |
| ClassDeclaration cd = e.type.isClassHandle(); |
| ClassDeclaration tcd = t.isClassHandle(); |
| if (cd && tcd && (tcd == cd || cd.isBaseOf(tcd, null))) |
| { |
| e = new DotTypeExp(e1.loc, e1, cd); |
| e = new DotVarExp(e.loc, e, d); |
| e = e.expressionSemantic(sc); |
| return e; |
| } |
| if (tcd && tcd.isNested()) |
| { |
| /* e1 is the 'this' pointer for an inner class: tcd. |
| * Rewrite it as the 'this' pointer for the outer class. |
| */ |
| auto vthis = tcd.followInstantiationContext(ad) ? tcd.vthis2 : tcd.vthis; |
| e1 = new DotVarExp(e.loc, e1, vthis); |
| e1.type = vthis.type; |
| e1.type = e1.type.addMod(t.mod); |
| // Do not call ensureStaticLinkTo() |
| //e1 = e1.expressionSemantic(sc); |
| |
| // Skip up over nested functions, and get the enclosing |
| // class type. |
| e1 = getThisSkipNestedFuncs(e1.loc, sc, tcd.toParentP(ad), ad, e1, t, d, true); |
| if (!e1) |
| { |
| e = new VarExp(e.loc, d); |
| return e; |
| } |
| goto L2; |
| } |
| } |
| } |
| //printf("e = %s, d = %s\n", e.toChars(), d.toChars()); |
| if (d.semanticRun == PASS.initial) |
| d.dsymbolSemantic(null); |
| |
| // If static function, get the most visible overload. |
| // Later on the call is checked for correctness. |
| // https://issues.dlang.org/show_bug.cgi?id=12511 |
| Dsymbol d2 = d; |
| if (auto fd = d.isFuncDeclaration()) |
| { |
| import dmd.access : mostVisibleOverload; |
| d2 = mostVisibleOverload(fd, sc._module); |
| } |
| |
| checkAccess(e.loc, sc, e, d2); |
| if (d2.isDeclaration()) |
| { |
| d = cast(Declaration)d2; |
| auto ve = new VarExp(e.loc, d); |
| if (d.isVarDeclaration() && d.needThis()) |
| ve.type = d.type.addMod(e.type.mod); |
| return ve; |
| } |
| else if (d2.isTemplateDeclaration()) |
| { |
| return toTemplateExp(cast(TemplateDeclaration)d2); |
| } |
| else |
| assert(0); |
| } |
| |
| bool unreal = e.op == EXP.variable && (cast(VarExp)e).var.isField(); |
| if (d.isDataseg() || unreal && d.isField()) |
| { |
| // (e, d) |
| checkAccess(e.loc, sc, e, d); |
| Expression ve = new VarExp(e.loc, d); |
| e = unreal ? ve : new CommaExp(e.loc, e, ve); |
| e = e.expressionSemantic(sc); |
| return e; |
| } |
| |
| e = new DotVarExp(e.loc, e, d); |
| e = e.expressionSemantic(sc); |
| return e; |
| } |
| |
| switch (mt.ty) |
| { |
| case Tvector: return visitVector (mt.isTypeVector()); |
| case Tsarray: return visitSArray (mt.isTypeSArray()); |
| case Tstruct: return visitStruct (mt.isTypeStruct()); |
| case Tenum: return visitEnum (mt.isTypeEnum()); |
| case Terror: return visitError (mt.isTypeError()); |
| case Tarray: return visitDArray (mt.isTypeDArray()); |
| case Taarray: return visitAArray (mt.isTypeAArray()); |
| case Treference: return visitReference(mt.isTypeReference()); |
| case Tdelegate: return visitDelegate (mt.isTypeDelegate()); |
| case Tclass: return visitClass (mt.isTypeClass()); |
| |
| default: return mt.isTypeBasic() |
| ? visitBasic(cast(TypeBasic)mt) |
| : visitType(mt); |
| } |
| } |
| |
| |
| /************************ |
| * Get the default initialization expression for a type. |
| * Params: |
| * mt = the type for which the init expression is returned |
| * loc = the location where the expression needs to be evaluated |
| * isCfile = default initializers are different with C |
| * |
| * Returns: |
| * The initialization expression for the type. |
| */ |
| extern (C++) Expression defaultInit(Type mt, const ref Loc loc, const bool isCfile = false) |
| { |
| Expression visitBasic(TypeBasic mt) |
| { |
| static if (LOGDEFAULTINIT) |
| { |
| printf("TypeBasic::defaultInit() '%s' isCfile: %d\n", mt.toChars(), isCfile); |
| } |
| dinteger_t value = 0; |
| |
| switch (mt.ty) |
| { |
| case Tchar: |
| value = isCfile ? 0 : 0xFF; |
| break; |
| |
| case Twchar: |
| case Tdchar: |
| value = isCfile ? 0 : 0xFFFF; |
| break; |
| |
| case Timaginary32: |
| case Timaginary64: |
| case Timaginary80: |
| case Tfloat32: |
| case Tfloat64: |
| case Tfloat80: |
| return new RealExp(loc, isCfile ? CTFloat.zero : target.RealProperties.nan, mt); |
| |
| case Tcomplex32: |
| case Tcomplex64: |
| case Tcomplex80: |
| { |
| // Can't use fvalue + I*fvalue (the im part becomes a quiet NaN). |
| const cvalue = isCfile ? complex_t(CTFloat.zero, CTFloat.zero) |
| : complex_t(target.RealProperties.nan, target.RealProperties.nan); |
| return new ComplexExp(loc, cvalue, mt); |
| } |
| |
| case Tvoid: |
| error(loc, "`void` does not have a default initializer"); |
| return ErrorExp.get(); |
| |
| default: |
| break; |
| } |
| return new IntegerExp(loc, value, mt); |
| } |
| |
| Expression visitVector(TypeVector mt) |
| { |
| //printf("TypeVector::defaultInit()\n"); |
| assert(mt.basetype.ty == Tsarray); |
| Expression e = mt.basetype.defaultInit(loc, isCfile); |
| auto ve = new VectorExp(loc, e, mt); |
| ve.type = mt; |
| ve.dim = cast(int)(mt.basetype.size(loc) / mt.elementType().size(loc)); |
| return ve; |
| } |
| |
| Expression visitSArray(TypeSArray mt) |
| { |
| static if (LOGDEFAULTINIT) |
| { |
| printf("TypeSArray::defaultInit() '%s' isCfile %d\n", mt.toChars(), isCfile); |
| } |
| if (mt.next.ty == Tvoid) |
| return mt.tuns8.defaultInit(loc, isCfile); |
| else |
| return mt.next.defaultInit(loc, isCfile); |
| } |
| |
| Expression visitFunction(TypeFunction mt) |
| { |
| error(loc, "`function` does not have a default initializer"); |
| return ErrorExp.get(); |
| } |
| |
| Expression visitStruct(TypeStruct mt) |
| { |
| static if (LOGDEFAULTINIT) |
| { |
| printf("TypeStruct::defaultInit() '%s'\n", mt.toChars()); |
| } |
| Declaration d = new SymbolDeclaration(mt.sym.loc, mt.sym); |
| assert(d); |
| d.type = mt; |
| d.storage_class |= STC.rvalue; // https://issues.dlang.org/show_bug.cgi?id=14398 |
| return new VarExp(mt.sym.loc, d); |
| } |
| |
| Expression visitEnum(TypeEnum mt) |
| { |
| static if (LOGDEFAULTINIT) |
| { |
| printf("TypeEnum::defaultInit() '%s'\n", mt.toChars()); |
| } |
| // Initialize to first member of enum |
| Expression e = mt.sym.getDefaultValue(loc); |
| e = e.copy(); |
| e.loc = loc; |
| e.type = mt; // to deal with const, immutable, etc., variants |
| return e; |
| } |
| |
| Expression visitTuple(TypeTuple mt) |
| { |
| static if (LOGDEFAULTINIT) |
| { |
| printf("TypeTuple::defaultInit() '%s'\n", mt.toChars()); |
| } |
| auto exps = new Expressions(mt.arguments.length); |
| for (size_t i = 0; i < mt.arguments.length; i++) |
| { |
| Parameter p = (*mt.arguments)[i]; |
| assert(p.type); |
| Expression e = p.type.defaultInitLiteral(loc); |
| if (e.op == EXP.error) |
| { |
| return e; |
| } |
| (*exps)[i] = e; |
| } |
| return new TupleExp(loc, exps); |
| } |
| |
| Expression visitNoreturn(TypeNoreturn mt) |
| { |
| static if (LOGDEFAULTINIT) |
| { |
| printf("TypeNoreturn::defaultInit() '%s'\n", mt.toChars()); |
| } |
| auto cond = IntegerExp.createBool(false); |
| auto msg = new StringExp(loc, "Accessed expression of type `noreturn`"); |
| msg.type = Type.tstring; |
| auto ae = new AssertExp(loc, cond, msg); |
| ae.type = mt; |
| return ae; |
| } |
| |
| switch (mt.ty) |
| { |
| case Tvector: return visitVector (mt.isTypeVector()); |
| case Tsarray: return visitSArray (mt.isTypeSArray()); |
| case Tfunction: return visitFunction(mt.isTypeFunction()); |
| case Tstruct: return visitStruct (mt.isTypeStruct()); |
| case Tenum: return visitEnum (mt.isTypeEnum()); |
| case Ttuple: return visitTuple (mt.isTypeTuple()); |
| |
| case Tnull: return new NullExp(Loc.initial, Type.tnull); |
| |
| case Terror: return ErrorExp.get(); |
| |
| case Tarray: |
| case Taarray: |
| case Tpointer: |
| case Treference: |
| case Tdelegate: |
| case Tclass: return new NullExp(loc, mt); |
| case Tnoreturn: return visitNoreturn(mt.isTypeNoreturn()); |
| |
| default: return mt.isTypeBasic() ? |
| visitBasic(cast(TypeBasic)mt) : |
| null; |
| } |
| } |
| |
| /******************************* Private *****************************************/ |
| |
| private: |
| |
| /* Helper function for `typeToExpression`. Contains common code |
| * for TypeQualified derived classes. |
| */ |
| Expression typeToExpressionHelper(TypeQualified t, Expression e, size_t i = 0) |
| { |
| //printf("toExpressionHelper(e = %s %s)\n", EXPtoString(e.op).ptr, e.toChars()); |
| foreach (id; t.idents[i .. t.idents.length]) |
| { |
| //printf("\t[%d] e: '%s', id: '%s'\n", i, e.toChars(), id.toChars()); |
| |
| final switch (id.dyncast()) |
| { |
| // ... '. ident' |
| case DYNCAST.identifier: |
| e = new DotIdExp(e.loc, e, cast(Identifier)id); |
| break; |
| |
| // ... '. name!(tiargs)' |
| case DYNCAST.dsymbol: |
| auto ti = (cast(Dsymbol)id).isTemplateInstance(); |
| assert(ti); |
| e = new DotTemplateInstanceExp(e.loc, e, ti.name, ti.tiargs); |
| break; |
| |
| // ... '[type]' |
| case DYNCAST.type: // https://issues.dlang.org/show_bug.cgi?id=1215 |
| e = new ArrayExp(t.loc, e, new TypeExp(t.loc, cast(Type)id)); |
| break; |
| |
| // ... '[expr]' |
| case DYNCAST.expression: // https://issues.dlang.org/show_bug.cgi?id=1215 |
| e = new ArrayExp(t.loc, e, cast(Expression)id); |
| break; |
| |
| case DYNCAST.object: |
| case DYNCAST.tuple: |
| case DYNCAST.parameter: |
| case DYNCAST.statement: |
| case DYNCAST.condition: |
| case DYNCAST.templateparameter: |
| case DYNCAST.initializer: |
| assert(0); |
| } |
| } |
| return e; |
| } |
| |
| /************************** |
| * This evaluates exp while setting length to be the number |
| * of elements in the tuple t. |
| */ |
| Expression semanticLength(Scope* sc, Type t, Expression exp) |
| { |
| if (auto tt = t.isTypeTuple()) |
| { |
| ScopeDsymbol sym = new ArrayScopeSymbol(sc, tt); |
| sym.parent = sc.scopesym; |
| sc = sc.push(sym); |
| sc = sc.startCTFE(); |
| exp = exp.expressionSemantic(sc); |
| exp = resolveProperties(sc, exp); |
| sc = sc.endCTFE(); |
| sc.pop(); |
| } |
| else |
| { |
| sc = sc.startCTFE(); |
| exp = exp.expressionSemantic(sc); |
| exp = resolveProperties(sc, exp); |
| sc = sc.endCTFE(); |
| } |
| return exp; |
| } |
| |
| Expression semanticLength(Scope* sc, TupleDeclaration tup, Expression exp) |
| { |
| ScopeDsymbol sym = new ArrayScopeSymbol(sc, tup); |
| sym.parent = sc.scopesym; |
| |
| sc = sc.push(sym); |
| sc = sc.startCTFE(); |
| exp = exp.expressionSemantic(sc); |
| exp = resolveProperties(sc, exp); |
| sc = sc.endCTFE(); |
| sc.pop(); |
| |
| return exp; |
| } |
| |
| /************************************ |
| * Transitively search a type for all function types. |
| * If any function types with parameters are found that have parameter identifiers |
| * or default arguments, remove those and create a new type stripped of those. |
| * This is used to determine the "canonical" version of a type which is useful for |
| * comparisons. |
| * Params: |
| * t = type to scan |
| * Returns: |
| * `t` if no parameter identifiers or default arguments found, otherwise a new type that is |
| * the same as t but with no parameter identifiers or default arguments. |
| */ |
| Type stripDefaultArgs(Type t) |
| { |
| static Parameters* stripParams(Parameters* parameters) |
| { |
| static Parameter stripParameter(Parameter p) |
| { |
| Type t = stripDefaultArgs(p.type); |
| return (t != p.type || p.defaultArg || p.ident || p.userAttribDecl) |
| ? new Parameter(p.storageClass, t, null, null, null) |
| : null; |
| } |
| |
| if (parameters) |
| { |
| foreach (i, p; *parameters) |
| { |
| Parameter ps = stripParameter(p); |
| if (ps) |
| { |
| // Replace params with a copy we can modify |
| Parameters* nparams = new Parameters(parameters.length); |
| |
| foreach (j, ref np; *nparams) |
| { |
| Parameter pj = (*parameters)[j]; |
| if (j < i) |
| np = pj; |
| else if (j == i) |
| np = ps; |
| else |
| { |
| Parameter nps = stripParameter(pj); |
| np = nps ? nps : pj; |
| } |
| } |
| return nparams; |
| } |
| } |
| } |
| return parameters; |
| } |
| |
| if (t is null) |
| return t; |
| |
| if (auto tf = t.isTypeFunction()) |
| { |
| Type tret = stripDefaultArgs(tf.next); |
| Parameters* params = stripParams(tf.parameterList.parameters); |
| if (tret == tf.next && params == tf.parameterList.parameters) |
| return t; |
| TypeFunction tr = tf.copy().isTypeFunction(); |
| tr.parameterList.parameters = params; |
| tr.next = tret; |
| //printf("strip %s\n <- %s\n", tr.toChars(), t.toChars()); |
| return tr; |
| } |
| else if (auto tt = t.isTypeTuple()) |
| { |
| Parameters* args = stripParams(tt.arguments); |
| if (args == tt.arguments) |
| return t; |
| TypeTuple tr = t.copy().isTypeTuple(); |
| tr.arguments = args; |
| return tr; |
| } |
| else if (t.ty == Tenum) |
| { |
| // TypeEnum::nextOf() may be != NULL, but it's not necessary here. |
| return t; |
| } |
| else |
| { |
| Type tn = t.nextOf(); |
| Type n = stripDefaultArgs(tn); |
| if (n == tn) |
| return t; |
| TypeNext tr = cast(TypeNext)t.copy(); |
| tr.next = n; |
| return tr; |
| } |
| } |
| |
| /****************************** |
| * Get the value of the .max/.min property of `ed` as an Expression. |
| * Lazily computes the value and caches it in maxval/minval. |
| * Reports any errors. |
| * Params: |
| * ed = the EnumDeclaration being examined |
| * loc = location to use for error messages |
| * id = Id::max or Id::min |
| * Returns: |
| * corresponding value of .max/.min |
| */ |
| Expression getMaxMinValue(EnumDeclaration ed, const ref Loc loc, Identifier id) |
| { |
| //printf("EnumDeclaration::getMaxValue()\n"); |
| |
| static Expression pvalToResult(Expression e, const ref Loc loc) |
| { |
| if (e.op != EXP.error) |
| { |
| e = e.copy(); |
| e.loc = loc; |
| } |
| return e; |
| } |
| |
| Expression* pval = (id == Id.max) ? &ed.maxval : &ed.minval; |
| |
| Expression errorReturn() |
| { |
| *pval = ErrorExp.get(); |
| return *pval; |
| } |
| |
| if (ed.inuse) |
| { |
| ed.error(loc, "recursive definition of `.%s` property", id.toChars()); |
| return errorReturn(); |
| } |
| if (*pval) |
| return pvalToResult(*pval, loc); |
| |
| if (ed._scope) |
| dsymbolSemantic(ed, ed._scope); |
| if (ed.errors) |
| return errorReturn(); |
| if (!ed.members) |
| { |
| ed.error(loc, "is opaque and has no `.%s`", id.toChars()); |
| return errorReturn(); |
| } |
| if (!(ed.memtype && ed.memtype.isintegral())) |
| { |
| ed.error(loc, "has no `.%s` property because base type `%s` is not an integral type", |
| id.toChars(), ed.memtype ? ed.memtype.toChars() : ""); |
| return errorReturn(); |
| } |
| |
| bool first = true; |
| for (size_t i = 0; i < ed.members.length; i++) |
| { |
| EnumMember em = (*ed.members)[i].isEnumMember(); |
| if (!em) |
| continue; |
| if (em.errors) |
| { |
| ed.errors = true; |
| continue; |
| } |
| |
| if (em.semanticRun < PASS.semanticdone) |
| { |
| em.error("is forward referenced looking for `.%s`", id.toChars()); |
| ed.errors = true; |
| continue; |
| } |
| |
| if (first) |
| { |
| *pval = em.value; |
| first = false; |
| } |
| else |
| { |
| /* In order to work successfully with UDTs, |
| * build expressions to do the comparisons, |
| * and let the semantic analyzer and constant |
| * folder give us the result. |
| */ |
| |
| /* Compute: |
| * if (e > maxval) |
| * maxval = e; |
| */ |
| Expression e = em.value; |
| Expression ec = new CmpExp(id == Id.max ? EXP.greaterThan : EXP.lessThan, em.loc, e, *pval); |
| ed.inuse = true; |
| ec = ec.expressionSemantic(em._scope); |
| ed.inuse = false; |
| ec = ec.ctfeInterpret(); |
| if (ec.op == EXP.error) |
| { |
| ed.errors = true; |
| continue; |
| } |
| if (ec.toInteger()) |
| *pval = e; |
| } |
| } |
| return ed.errors ? errorReturn() : pvalToResult(*pval, loc); |
| } |
| |
| /****************************************** |
| * Compile the MixinType, returning the type or expression AST. |
| * |
| * Doesn't run semantic() on the returned object. |
| * Params: |
| * tm = mixin to compile as a type or expression |
| * loc = location for error messages |
| * sc = context |
| * Return: |
| * null if error, else RootObject AST as parsed |
| */ |
| RootObject compileTypeMixin(TypeMixin tm, Loc loc, Scope* sc) |
| { |
| OutBuffer buf; |
| if (expressionsToString(buf, sc, tm.exps)) |
| return null; |
| |
| const errors = global.errors; |
| const len = buf.length; |
| buf.writeByte(0); |
| const str = buf.extractSlice()[0 .. len]; |
| scope p = new Parser!ASTCodegen(loc, sc._module, str, false, global.errorSink); |
| p.nextToken(); |
| //printf("p.loc.linnum = %d\n", p.loc.linnum); |
| |
| auto o = p.parseTypeOrAssignExp(TOK.endOfFile); |
| if (errors != global.errors) |
| { |
| assert(global.errors != errors); // should have caught all these cases |
| return null; |
| } |
| if (p.token.value != TOK.endOfFile) |
| { |
| .error(loc, "incomplete mixin type `%s`", str.ptr); |
| return null; |
| } |
| |
| return o; |
| } |