@@ -64,6 +64,7 @@ D_FRONTEND_OBJS = \
d/blockexit.o \
d/canthrow.o \
d/checkedint.o \
+ d/chkformat.o \
d/clone.o \
d/cond.o \
d/constfold.o \
@@ -1153,6 +1153,14 @@ build_struct_literal (tree type, vec <constructor_elt, va_gc> *init)
if (vec_safe_is_empty (init))
return build_constructor (type, NULL);
+ /* Struct literals can be seen for special enums representing `_Complex',
+ make sure to reinterpret the literal as the correct type. */
+ if (COMPLEX_FLOAT_TYPE_P (type))
+ {
+ gcc_assert (vec_safe_length (init) == 2);
+ return build_complex (type, (*init)[0].value, (*init)[1].value);
+ }
+
vec <constructor_elt, va_gc> *ve = NULL;
HOST_WIDE_INT offset = 0;
bool constant_p = true;
@@ -559,7 +559,9 @@ convert_expr (tree exp, Type *etype, Type *totype)
break;
case Tnull:
- /* Casting from typeof(null) is represented as all zeros. */
+ case Tnoreturn:
+ /* Casting from `typeof(null)' for `null' expressions, or `typeof(*null)'
+ for `noreturn' expressions is represented as all zeros. */
result = build_typeof_null_value (totype);
/* Make sure the expression is still evaluated if necessary. */
@@ -742,6 +744,16 @@ convert_for_condition (tree expr, Type *type)
break;
}
+ case Tnoreturn:
+ /* Front-end allows conditionals that never return, represent the
+ conditional result value as all zeros. */
+ result = build_zero_cst (d_bool_type);
+
+ /* Make sure the expression is still evaluated if necessary. */
+ if (TREE_SIDE_EFFECTS (expr))
+ result = compound_expr (expr, result);
+ break;
+
default:
result = expr;
break;
@@ -164,6 +164,15 @@ Target::_init (const Param &)
this->c.longsize = int_size_in_bytes (long_integer_type_node);
this->c.long_doublesize = int_size_in_bytes (long_double_type_node);
+ /* Define what type to use for wchar_t. We don't want to support wide
+ characters less than "short" in D. */
+ if (WCHAR_TYPE_SIZE == 32)
+ this->c.twchar_t = Type::basic[Tdchar];
+ else if (WCHAR_TYPE_SIZE == 16)
+ this->c.twchar_t = Type::basic[Twchar];
+ else
+ sorry ("D does not support wide characters on this target.");
+
/* Set-up target C++ ABI. */
this->cpp.reverseOverloads = false;
this->cpp.exceptions = true;
@@ -417,6 +426,15 @@ TargetCPP::fundamentalType (const Type *, bool &)
return false;
}
+/* Get the starting offset position for fields of an `extern(C++)` class
+ that is derived from the given BASE_CLASS. */
+
+unsigned
+TargetCPP::derivedClassOffset(ClassDeclaration *base_class)
+{
+ return base_class->structsize;
+}
+
/* Return the default system linkage for the target. */
LINK
@@ -517,3 +535,13 @@ Target::getTargetInfo (const char *key, const Loc &loc)
return NULL;
}
+
+/**
+ * Returns true if the implementation for object monitors is always defined
+ * in the D runtime library (rt/monitor_.d). */
+
+bool
+Target::libraryObjectMonitors (FuncDeclaration *, Statement *)
+{
+ return true;
+}
@@ -1277,6 +1277,10 @@ get_symbol_decl (Declaration *decl)
if (decl->storage_class & STCfinal)
DECL_FINAL_P (decl->csym) = 1;
+ /* Function is of type `noreturn' or `typeof(*null)'. */
+ if (fd->type->nextOf ()->ty == Tnoreturn)
+ TREE_THIS_VOLATILE (decl->csym) = 1;
+
/* Check whether this function is expanded by the frontend. */
DECL_INTRINSIC_CODE (decl->csym) = INTRINSIC_NONE;
maybe_set_intrinsic (fd);
@@ -1,4 +1,4 @@
-a3c9bf422e7ff54d45846b8c577ee82da4234db1
+3b808e838bb00f527eb4ed5281cd985756237b8f
The first line of this file holds the git revision number of the last
merge done from the dlang/dmd repository.
@@ -80,8 +80,8 @@ Scope *AttribDeclaration::createNewScope(Scope *sc,
if (stc != sc->stc ||
linkage != sc->linkage ||
cppmangle != sc->cppmangle ||
- !protection.isSubsetOf(sc->protection) ||
explicitProtection != sc->explicitProtection ||
+ !(protection == sc->protection) ||
aligndecl != sc->aligndecl ||
inlining != sc->inlining)
{
@@ -552,10 +552,21 @@ void ProtDeclaration::addMember(Scope *sc, ScopeDsymbol *sds)
if (protection.kind == Prot::package_ && protection.pkg && sc->_module)
{
Module *m = sc->_module;
- Package* pkg = m->parent ? m->parent->isPackage() : NULL;
- if (!pkg || !protection.pkg->isAncestorPackageOf(pkg))
- error("does not bind to one of ancestor packages of module `%s`",
- m->toPrettyChars(true));
+
+ // While isAncestorPackageOf does an equality check, the fix for issue 17441 adds a check to see if
+ // each package's .isModule() properites are equal.
+ //
+ // Properties generated from `package(foo)` i.e. protection.pkg have .isModule() == null.
+ // This breaks package declarations of the package in question if they are declared in
+ // the same package.d file, which _do_ have a module associated with them, and hence a non-null
+ // isModule()
+ if (!m->isPackage() || !protection.pkg->ident->equals(m->isPackage()->ident))
+ {
+ Package* pkg = m->parent ? m->parent->isPackage() : NULL;
+ if (!pkg || !protection.pkg->isAncestorPackageOf(pkg))
+ error("does not bind to one of ancestor packages of module `%s`",
+ m->toPrettyChars(true));
+ }
}
return AttribDeclaration::addMember(sc, sds);
@@ -795,6 +806,18 @@ Scope *PragmaDeclaration::newScope(Scope *sc)
sc->protection, sc->explicitProtection, sc->aligndecl,
inlining);
}
+ if (ident == Id::printf || ident == Id::scanf)
+ {
+ Scope *sc2 = sc->push();
+
+ if (ident == Id::printf)
+ // Override previous setting, never let both be set
+ sc2->flags = (sc2->flags & ~SCOPEscanf) | SCOPEprintf;
+ else
+ sc2->flags = (sc2->flags & ~SCOPEprintf) | SCOPEscanf;
+
+ return sc2;
+ }
return sc;
}
@@ -1164,12 +1187,12 @@ void ForwardingAttribDeclaration::addMember(Scope *sc, ScopeDsymbol *sds)
// These are mixin declarations, like mixin("int x");
-CompileDeclaration::CompileDeclaration(Loc loc, Expression *exp)
+CompileDeclaration::CompileDeclaration(Loc loc, Expressions *exps)
: AttribDeclaration(NULL)
{
//printf("CompileDeclaration(loc = %d)\n", loc.linnum);
this->loc = loc;
- this->exp = exp;
+ this->exps = exps;
this->scopesym = NULL;
this->compiled = false;
}
@@ -1177,7 +1200,7 @@ CompileDeclaration::CompileDeclaration(Loc loc, Expression *exp)
Dsymbol *CompileDeclaration::syntaxCopy(Dsymbol *)
{
//printf("CompileDeclaration::syntaxCopy('%s')\n", toChars());
- return new CompileDeclaration(loc, exp->syntaxCopy());
+ return new CompileDeclaration(loc, Expression::arraySyntaxCopy(exps));
}
void CompileDeclaration::addMember(Scope *, ScopeDsymbol *sds)
@@ -234,12 +234,12 @@ public:
class CompileDeclaration : public AttribDeclaration
{
public:
- Expression *exp;
+ Expressions *exps;
ScopeDsymbol *scopesym;
bool compiled;
- CompileDeclaration(Loc loc, Expression *exp);
+ CompileDeclaration(Loc loc, Expressions *exps);
Dsymbol *syntaxCopy(Dsymbol *s);
void addMember(Scope *sc, ScopeDsymbol *sds);
void setScope(Scope *sc);
@@ -62,6 +62,8 @@ int blockExit(Statement *s, FuncDeclaration *func, bool mustNotThrow)
return;
}
}
+ if (s->exp->type->toBasetype()->isTypeNoreturn())
+ result = BEhalt;
if (canThrow(s->exp, func, mustNotThrow))
result |= BEthrow;
}
new file mode 100644
@@ -0,0 +1,975 @@
+
+/* Compiler implementation of the D programming language
+ * Copyright (C) 1999-2021 by The D Language Foundation, All Rights Reserved
+ * written by Walter Bright
+ * http://www.digitalmars.com
+ * Distributed under the Boost Software License, Version 1.0.
+ * http://www.boost.org/LICENSE_1_0.txt
+ */
+
+// Check the arguments to `printf` and `scanf` against the `format` string.
+
+#include "root/dsystem.h"
+#include "root/dcompat.h"
+
+#include "arraytypes.h"
+#include "cond.h"
+#include "errors.h"
+#include "expression.h"
+#include "globals.h"
+#include "identifier.h"
+#include "mtype.h"
+#include "target.h"
+
+
+/* Different kinds of formatting specifications, variations we don't
+ care about are merged. (Like we don't care about the difference between
+ f, e, g, a, etc.)
+
+ For `scanf`, every format is a pointer.
+ */
+enum Format
+{
+ Format_d, // int
+ Format_hhd, // signed char
+ Format_hd, // short int
+ Format_ld, // long int
+ Format_lld, // long long int
+ Format_jd, // intmax_t
+ Format_zd, // size_t
+ Format_td, // ptrdiff_t
+ Format_u, // unsigned int
+ Format_hhu, // unsigned char
+ Format_hu, // unsigned short int
+ Format_lu, // unsigned long int
+ Format_llu, // unsigned long long int
+ Format_ju, // uintmax_t
+ Format_g, // float (scanf) / double (printf)
+ Format_lg, // double (scanf)
+ Format_Lg, // long double (both)
+ Format_s, // char string (both)
+ Format_ls, // wchar_t string (both)
+ Format_c, // char (printf)
+ Format_lc, // wint_t (printf)
+ Format_p, // pointer
+ Format_n, // pointer to int
+ Format_hhn, // pointer to signed char
+ Format_hn, // pointer to short
+ Format_ln, // pointer to long int
+ Format_lln, // pointer to long long int
+ Format_jn, // pointer to intmax_t
+ Format_zn, // pointer to size_t
+ Format_tn, // pointer to ptrdiff_t
+ Format_GNU_a, // GNU ext. : address to a string with no maximum size (scanf)
+ Format_GNU_m, // GNU ext. : string corresponding to the error code in errno (printf) / length modifier (scanf)
+ Format_percent, // %% (i.e. no argument)
+ Format_error, // invalid format specification
+};
+
+/**************************************
+ * Parse the *length specifier* and the *specifier* of the following form:
+ * `[length]specifier`
+ *
+ * Params:
+ * format = format string
+ * idx = index of of start of format specifier,
+ * which gets updated to index past the end of it,
+ * even if `Format_error` is returned
+ * genSpecifier = Generic specifier. For instance, it will be set to `d` if the
+ * format is `hdd`.
+ * Returns:
+ * Format
+ */
+static Format parseGenericFormatSpecifier(const char *format,
+ size_t &idx, char &genSpecifier, bool useGNUExts =
+ findCondition(global.versionids, Identifier::idPool("CRuntime_Glibc")))
+{
+ genSpecifier = 0;
+
+ const size_t length = strlen(format);
+
+ /* Read the `length modifier`
+ */
+ const char lm = format[idx];
+ bool lm1= false; // if jztL
+ bool lm2= false; // if `hh` or `ll`
+ if (lm == 'j' ||
+ lm == 'z' ||
+ lm == 't' ||
+ lm == 'L')
+ {
+ ++idx;
+ if (idx == length)
+ return Format_error;
+ lm1 = true;
+ }
+ else if (lm == 'h' || lm == 'l')
+ {
+ ++idx;
+ if (idx == length)
+ return Format_error;
+ lm2 = lm == format[idx];
+ if (lm2)
+ {
+ ++idx;
+ if (idx == length)
+ return Format_error;
+ }
+ }
+
+ /* Read the `specifier`
+ */
+ Format specifier;
+ const char sc = format[idx];
+ genSpecifier = sc;
+ switch (sc)
+ {
+ case 'd':
+ case 'i':
+ if (lm == 'L')
+ specifier = Format_error;
+ else
+ specifier = lm == 'h' && lm2 ? Format_hhd :
+ lm == 'h' ? Format_hd :
+ lm == 'l' && lm2 ? Format_lld :
+ lm == 'l' ? Format_ld :
+ lm == 'j' ? Format_jd :
+ lm == 'z' ? Format_zd :
+ lm == 't' ? Format_td :
+ Format_d;
+ break;
+
+ case 'u':
+ case 'o':
+ case 'x':
+ case 'X':
+ if (lm == 'L')
+ specifier = Format_error;
+ else
+ specifier = lm == 'h' && lm2 ? Format_hhu :
+ lm == 'h' ? Format_hu :
+ lm == 'l' && lm2 ? Format_llu :
+ lm == 'l' ? Format_lu :
+ lm == 'j' ? Format_ju :
+ lm == 'z' ? Format_zd :
+ lm == 't' ? Format_td :
+ Format_u;
+ break;
+
+ case 'a':
+ if (useGNUExts)
+ {
+ // https://www.gnu.org/software/libc/manual/html_node/Dynamic-String-Input.html
+ specifier = Format_GNU_a;
+ break;
+ }
+ /* fall through */
+
+ case 'f':
+ case 'F':
+ case 'e':
+ case 'E':
+ case 'g':
+ case 'G':
+ case 'A':
+ if (lm == 'L')
+ specifier = Format_Lg;
+ else if (lm1 || lm2 || lm == 'h')
+ specifier = Format_error;
+ else
+ specifier = lm == 'l' ? Format_lg : Format_g;
+ break;
+
+ case 'c':
+ if (lm1 || lm2 || lm == 'h')
+ specifier = Format_error;
+ else
+ specifier = lm == 'l' ? Format_lc : Format_c;
+ break;
+
+ case 's':
+ if (lm1 || lm2 || lm == 'h')
+ specifier = Format_error;
+ else
+ specifier = lm == 'l' ? Format_ls : Format_s;
+ break;
+
+ case 'p':
+ if (lm1 || lm2 || lm == 'h' || lm == 'l')
+ specifier = Format_error;
+ else
+ specifier = Format_p;
+ break;
+
+ case 'n':
+ if (lm == 'L')
+ specifier = Format_error;
+ else
+ specifier = lm == 'l' && lm2 ? Format_lln :
+ lm == 'l' ? Format_ln :
+ lm == 'h' && lm2 ? Format_hhn :
+ lm == 'h' ? Format_hn :
+ lm == 'j' ? Format_jn :
+ lm == 'z' ? Format_zn :
+ lm == 't' ? Format_tn :
+ Format_n;
+ break;
+
+ case 'm':
+ if (useGNUExts)
+ {
+ // http://www.gnu.org/software/libc/manual/html_node/Other-Output-Conversions.html
+ specifier = Format_GNU_m;
+ break;
+ }
+ goto Ldefault;
+
+ default:
+ Ldefault:
+ specifier = Format_error;
+ break;
+ }
+
+ ++idx;
+ return specifier; // success
+}
+
+Format formatError(size_t &idx, size_t i)
+{
+ idx = i;
+ return Format_error;
+}
+
+/**************************************
+ * Parse the *format specifier* which is of the form:
+ *
+ * `%[*][width][length]specifier`
+ *
+ * Params:
+ * format = format string
+ * idx = index of `%` of start of format specifier,
+ * which gets updated to index past the end of it,
+ * even if `Format_error` is returned
+ * asterisk = set if there is a `*` sub-specifier
+ * Returns:
+ * Format
+ */
+static Format parseScanfFormatSpecifier(const char *format, size_t &idx,
+ bool &asterisk)
+{
+ asterisk = false;
+
+ size_t i = idx;
+ assert(format[i] == '%');
+ const size_t length = strlen(format);
+
+ ++i;
+ if (i == length)
+ return formatError(idx, i);
+
+ if (format[i] == '%')
+ {
+ idx = i + 1;
+ return Format_percent;
+ }
+
+ // * sub-specifier
+ if (format[i] == '*')
+ {
+ ++i;
+ if (i == length)
+ return formatError(idx, i);
+ asterisk = true;
+ }
+
+ // fieldWidth
+ while (isdigit(format[i]))
+ {
+ i++;
+ if (i == length)
+ return formatError(idx, i);
+ }
+
+ /* Read the scanset
+ * A scanset can be anything, so we just check that it is paired
+ */
+ if (format[i] == '[')
+ {
+ while (i < length)
+ {
+ if (format[i] == ']')
+ break;
+ ++i;
+ }
+
+ // no `]` found
+ if (i == length)
+ return formatError(idx, i);
+
+ ++i;
+ // no specifier after `]`
+ // it could be mixed with the one above, but then idx won't have the right index
+ if (i == length)
+ return formatError(idx, i);
+ }
+
+ /* Read the specifier
+ */
+ char genSpec;
+ Format specifier = parseGenericFormatSpecifier(format, i, genSpec);
+ if (specifier == Format_error)
+ return formatError(idx, i);
+
+ idx = i;
+ return specifier; // success
+}
+
+/**************************************
+ * Parse the *format specifier* which is of the form:
+ *
+ * `%[flags][field width][.precision][length modifier]specifier`
+ *
+ * Params:
+ * format = format string
+ * idx = index of `%` of start of format specifier,
+ * which gets updated to index past the end of it,
+ * even if `Format_error` is returned
+ * widthStar = set if * for width
+ * precisionStar = set if * for precision
+ * Returns:
+ * Format
+ */
+static Format parsePrintfFormatSpecifier(const char *format, size_t &idx,
+ bool &widthStar, bool &precisionStar)
+{
+ widthStar = false;
+ precisionStar = false;
+
+ size_t i = idx;
+ assert(format[i] == '%');
+ const size_t format_length = strlen(format);
+ const size_t length = format_length;
+ bool hash = false;
+ bool zero = false;
+ bool flags = false;
+ bool width = false;
+ bool precision = false;
+
+ ++i;
+ if (i == length)
+ return formatError(idx, i);
+
+ if (format[i] == '%')
+ {
+ idx = i + 1;
+ return Format_percent;
+ }
+
+ /* Read the `flags`
+ */
+ while (1)
+ {
+ const char c = format[i];
+ if (c == '-' ||
+ c == '+' ||
+ c == ' ')
+ {
+ flags = true;
+ }
+ else if (c == '#')
+ {
+ hash = true;
+ }
+ else if (c == '0')
+ {
+ zero = true;
+ }
+ else
+ break;
+ ++i;
+ if (i == length)
+ return formatError(idx, i);
+ }
+
+ /* Read the `field width`
+ */
+ {
+ const char c = format[i];
+ if (c == '*')
+ {
+ width = true;
+ widthStar = true;
+ ++i;
+ if (i == length)
+ return formatError(idx, i);
+ }
+ else if ('1' <= c && c <= '9')
+ {
+ width = true;
+ ++i;
+ if (i == length)
+ return formatError(idx, i);
+ while ('0' <= format[i] && format[i] <= '9')
+ {
+ ++i;
+ if (i == length)
+ return formatError(idx, i);
+ }
+ }
+ }
+
+ /* Read the `precision`
+ */
+ if (format[i] == '.')
+ {
+ precision = true;
+ ++i;
+ if (i == length)
+ return formatError(idx, i);
+ const char c = format[i];
+ if (c == '*')
+ {
+ precisionStar = true;
+ ++i;
+ if (i == length)
+ return formatError(idx, i);
+ }
+ else if ('0' <= c && c <= '9')
+ {
+ ++i;
+ if (i == length)
+ return formatError(idx, i);
+ while ('0' <= format[i] && format[i] <= '9')
+ {
+ ++i;
+ if (i == length)
+ return formatError(idx, i);
+ }
+ }
+ }
+
+ /* Read the specifier
+ */
+ char genSpec;
+ Format specifier = parseGenericFormatSpecifier(format, i, genSpec);
+ if (specifier == Format_error)
+ return formatError(idx, i);
+
+ switch (genSpec)
+ {
+ case 'c':
+ case 's':
+ if (hash || zero)
+ return formatError(idx, i);
+ break;
+
+ case 'd':
+ case 'i':
+ if (hash)
+ return formatError(idx, i);
+ break;
+
+ case 'n':
+ if (hash || zero || precision || width || flags)
+ return formatError(idx, i);
+ break;
+
+ default:
+ break;
+ }
+
+ idx = i;
+ return specifier; // success
+}
+
+/*******************************************/
+
+static Expression *getNextPrintfArg(const Loc &loc, Expressions &args, size_t &n,
+ size_t gnu_m_count, bool &skip)
+{
+ if (n == args.length)
+ {
+ if (args.length < (n + 1) - gnu_m_count)
+ deprecation(loc, "more format specifiers than %d arguments", (int)n);
+ else
+ skip = true;
+ return NULL;
+ }
+ return args[n++];
+}
+
+static void errorPrintfFormat(const char *prefix, DString &slice, Expression *arg,
+ const char *texpect, Type *tactual)
+{
+ deprecation(arg->loc, "%sargument `%s` for format specification `\"%.*s\"` must be `%s`, not `%s`",
+ prefix ? prefix : "", arg->toChars(), (int)slice.length, slice.ptr, texpect, tactual->toChars());
+}
+
+/******************************************
+ * Check that arguments to a printf format string are compatible
+ * with that string. Issue errors for incompatibilities.
+ *
+ * Follows the C99 specification for printf.
+ *
+ * Takes a generous, rather than strict, view of compatiblity.
+ * For example, an unsigned value can be formatted with a signed specifier.
+ *
+ * Diagnosed incompatibilities are:
+ *
+ * 1. incompatible sizes which will cause argument misalignment
+ * 2. deferencing arguments that are not pointers
+ * 3. insufficient number of arguments
+ * 4. struct arguments
+ * 5. array and slice arguments
+ * 6. non-pointer arguments to `s` specifier
+ * 7. non-standard formats
+ * 8. undefined behavior per C99
+ *
+ * Per the C Standard, extra arguments are ignored.
+ *
+ * No attempt is made to fix the arguments or the format string.
+ *
+ * Params:
+ * loc = location for error messages
+ * format = format string
+ * args = arguments to match with format string
+ * isVa_list = if a "v" function (format check only)
+ *
+ * Returns:
+ * `true` if errors occurred
+ * References:
+ * C99 7.19.6.1
+ * http://www.cplusplus.com/reference/cstdio/printf/
+ */
+bool checkPrintfFormat(const Loc &loc, const char *format, Expressions &args, bool isVa_list)
+{
+ //printf("checkPrintFormat('%s')\n", format);
+ size_t n = 0; // index in args
+ size_t gnu_m_count = 0; // number of Format_GNU_m
+ const size_t format_length = strlen(format);
+ for (size_t i = 0; i < format_length;)
+ {
+ if (format[i] != '%')
+ {
+ ++i;
+ continue;
+ }
+ bool widthStar = false;
+ bool precisionStar = false;
+ size_t j = i;
+ const Format fmt = parsePrintfFormatSpecifier(format, j, widthStar, precisionStar);
+ DString slice = DString(j - i, format + i);
+ i = j;
+
+ if (fmt == Format_percent)
+ continue; // "%%", no arguments
+
+ if (isVa_list)
+ {
+ // format check only
+ if (fmt == Format_error)
+ deprecation(loc, "format specifier `\"%.*s\"` is invalid", (int)slice.length, slice.ptr);
+ continue;
+ }
+
+ if (fmt == Format_GNU_m)
+ ++gnu_m_count;
+
+ if (widthStar)
+ {
+ bool skip = false;
+ Expression *e = getNextPrintfArg(loc, args, n, gnu_m_count, skip);
+ if (skip)
+ continue;
+ if (!e)
+ return true;
+ Type *t = e->type->toBasetype();
+ if (t->ty != Tint32 && t->ty != Tuns32)
+ errorPrintfFormat("width ", slice, e, "int", t);
+ }
+
+ if (precisionStar)
+ {
+ bool skip = false;
+ Expression *e = getNextPrintfArg(loc, args, n, gnu_m_count, skip);
+ if (skip)
+ continue;
+ if (!e)
+ return true;
+ Type *t = e->type->toBasetype();
+ if (t->ty != Tint32 && t->ty != Tuns32)
+ errorPrintfFormat("precision ", slice, e, "int", t);
+ }
+
+ bool skip = false;
+ Expression *e = getNextPrintfArg(loc, args, n, gnu_m_count, skip);
+ if (skip)
+ continue;
+ if (!e)
+ return true;
+ Type *t = e->type->toBasetype();
+ Type *tnext = t->nextOf();
+ const unsigned c_longsize = target.c.longsize;
+ const bool is64bit = global.params.is64bit;
+
+ // Types which are promoted to int are allowed.
+ // Spec: C99 6.5.2.2.7
+ switch (fmt)
+ {
+ case Format_u: // unsigned int
+ case Format_d: // int
+ if (t->ty != Tint32 && t->ty != Tuns32)
+ errorPrintfFormat(NULL, slice, e, "int", t);
+ break;
+
+ case Format_hhu: // unsigned char
+ case Format_hhd: // signed char
+ if (t->ty != Tint32 && t->ty != Tuns32 && t->ty != Tint8 && t->ty != Tuns8)
+ errorPrintfFormat(NULL, slice, e, "byte", t);
+ break;
+
+ case Format_hu: // unsigned short int
+ case Format_hd: // short int
+ if (t->ty != Tint32 && t->ty != Tuns32 && t->ty != Tint16 && t->ty != Tuns16)
+ errorPrintfFormat(NULL, slice, e, "short", t);
+ break;
+
+ case Format_lu: // unsigned long int
+ case Format_ld: // long int
+ if (!(t->isintegral() && t->size() == c_longsize))
+ errorPrintfFormat(NULL, slice, e, (c_longsize == 4 ? "int" : "long"), t);
+ break;
+
+ case Format_llu: // unsigned long long int
+ case Format_lld: // long long int
+ if (t->ty != Tint64 && t->ty != Tuns64)
+ errorPrintfFormat(NULL, slice, e, "long", t);
+ break;
+
+ case Format_ju: // uintmax_t
+ case Format_jd: // intmax_t
+ if (t->ty != Tint64 && t->ty != Tuns64)
+ errorPrintfFormat(NULL, slice, e, "core.stdc.stdint.intmax_t", t);
+ break;
+
+ case Format_zd: // size_t
+ if (!(t->isintegral() && t->size() == (is64bit ? 8 : 4)))
+ errorPrintfFormat(NULL, slice, e, "size_t", t);
+ break;
+
+ case Format_td: // ptrdiff_t
+ if (!(t->isintegral() && t->size() == (is64bit ? 8 : 4)))
+ errorPrintfFormat(NULL, slice, e, "ptrdiff_t", t);
+ break;
+
+ case Format_GNU_a: // Format_GNU_a is only for scanf
+ case Format_lg:
+ case Format_g: // double
+ if (t->ty != Tfloat64 && t->ty != Timaginary64)
+ errorPrintfFormat(NULL, slice, e, "double", t);
+ break;
+
+ case Format_Lg: // long double
+ if (t->ty != Tfloat80 && t->ty != Timaginary80)
+ errorPrintfFormat(NULL, slice, e, "real", t);
+ break;
+
+ case Format_p: // pointer
+ if (t->ty != Tpointer && t->ty != Tnull && t->ty != Tclass && t->ty != Tdelegate && t->ty != Taarray)
+ errorPrintfFormat(NULL, slice, e, "void*", t);
+ break;
+
+ case Format_n: // pointer to int
+ if (!(t->ty == Tpointer && tnext->ty == Tint32))
+ errorPrintfFormat(NULL, slice, e, "int*", t);
+ break;
+
+ case Format_ln: // pointer to long int
+ if (!(t->ty == Tpointer && tnext->isintegral() && tnext->size() == c_longsize))
+ errorPrintfFormat(NULL, slice, e, (c_longsize == 4 ? "int*" : "long*"), t);
+ break;
+
+ case Format_lln: // pointer to long long int
+ if (!(t->ty == Tpointer && tnext->ty == Tint64))
+ errorPrintfFormat(NULL, slice, e, "long*", t);
+ break;
+
+ case Format_hn: // pointer to short
+ if (!(t->ty == Tpointer && tnext->ty == Tint16))
+ errorPrintfFormat(NULL, slice, e, "short*", t);
+ break;
+
+ case Format_hhn: // pointer to signed char
+ if (!(t->ty == Tpointer && tnext->ty == Tint16))
+ errorPrintfFormat(NULL, slice, e, "byte*", t);
+ break;
+
+ case Format_jn: // pointer to intmax_t
+ if (!(t->ty == Tpointer && tnext->ty == Tint64))
+ errorPrintfFormat(NULL, slice, e, "core.stdc.stdint.intmax_t*", t);
+ break;
+
+ case Format_zn: // pointer to size_t
+ if (!(t->ty == Tpointer && tnext->ty == (is64bit ? Tuns64 : Tuns32)))
+ errorPrintfFormat(NULL, slice, e, "size_t*", t);
+ break;
+
+ case Format_tn: // pointer to ptrdiff_t
+ if (!(t->ty == Tpointer && tnext->ty == (is64bit ? Tint64 : Tint32)))
+ errorPrintfFormat(NULL, slice, e, "ptrdiff_t*", t);
+ break;
+
+ case Format_c: // char
+ if (t->ty != Tint32 && t->ty != Tuns32)
+ errorPrintfFormat(NULL, slice, e, "char", t);
+ break;
+
+ case Format_lc: // wint_t
+ if (t->ty != Tint32 && t->ty != Tuns32)
+ errorPrintfFormat(NULL, slice, e, "wchar_t", t);
+ break;
+
+ case Format_s: // pointer to char string
+ if (!(t->ty == Tpointer && (tnext->ty == Tchar || tnext->ty == Tint8 || tnext->ty == Tuns8)))
+ errorPrintfFormat(NULL, slice, e, "char*", t);
+ break;
+
+ case Format_ls: // pointer to wchar_t string
+ {
+ if (!(t->ty == Tpointer && tnext == target.c.twchar_t))
+ errorPrintfFormat(NULL, slice, e, "wchar_t*", t);
+ break;
+ }
+ case Format_error:
+ deprecation(loc, "format specifier `\"%.*s\"` is invalid", (int)slice.length, slice.ptr);
+ break;
+
+ case Format_GNU_m:
+ break; // not assert(0) because it may go through it if there are extra arguments
+
+ case Format_percent:
+ default:
+ assert(0);
+ }
+ }
+ return false;
+}
+
+/*******************************************/
+
+static Expression *getNextScanfArg(const Loc &loc, Expressions &args, size_t &n, bool asterisk)
+{
+ if (n == args.length)
+ {
+ if (!asterisk)
+ deprecation(loc, "more format specifiers than %d arguments", (int)n);
+ return NULL;
+ }
+ return args[n++];
+}
+
+static void errorScanfFormat(const char *prefix, DString &slice,
+ Expression *arg, const char *texpect, Type *tactual)
+{
+ deprecation(arg->loc, "%sargument `%s` for format specification `\"%.*s\"` must be `%s`, not `%s`",
+ prefix ? prefix : "", arg->toChars(), (int)slice.length, slice.ptr, texpect, tactual->toChars());
+}
+
+/******************************************
+ * Check that arguments to a scanf format string are compatible
+ * with that string. Issue errors for incompatibilities.
+ *
+ * Follows the C99 specification for scanf.
+ *
+ * Takes a generous, rather than strict, view of compatiblity.
+ * For example, an unsigned value can be formatted with a signed specifier.
+ *
+ * Diagnosed incompatibilities are:
+ *
+ * 1. incompatible sizes which will cause argument misalignment
+ * 2. deferencing arguments that are not pointers
+ * 3. insufficient number of arguments
+ * 4. struct arguments
+ * 5. array and slice arguments
+ * 6. non-standard formats
+ * 7. undefined behavior per C99
+ *
+ * Per the C Standard, extra arguments are ignored.
+ *
+ * No attempt is made to fix the arguments or the format string.
+ *
+ * Params:
+ * loc = location for error messages
+ * format = format string
+ * args = arguments to match with format string
+ * isVa_list = if a "v" function (format check only)
+ *
+ * Returns:
+ * `true` if errors occurred
+ * References:
+ * C99 7.19.6.2
+ * http://www.cplusplus.com/reference/cstdio/scanf/
+ */
+bool checkScanfFormat(const Loc &loc, const char *format, Expressions &args, bool isVa_list)
+{
+ size_t n = 0;
+ const size_t format_length = strlen(format);
+ for (size_t i = 0; i < format_length;)
+ {
+ if (format[i] != '%')
+ {
+ ++i;
+ continue;
+ }
+ bool asterisk = false;
+ size_t j = i;
+ const Format fmt = parseScanfFormatSpecifier(format, j, asterisk);
+ DString slice = DString(j - i, format + i);
+ i = j;
+
+ if (fmt == Format_percent || asterisk)
+ continue; // "%%", "%*": no arguments
+
+ if (isVa_list)
+ {
+ // format check only
+ if (fmt == Format_error)
+ deprecation(loc, "format specifier `\"%.*s\"` is invalid", (int)slice.length, slice.ptr);
+ continue;
+ }
+
+ Expression *e = getNextScanfArg(loc, args, n, asterisk);
+ if (!e)
+ return true;
+
+ Type *t = e->type->toBasetype();
+ Type *tnext = t->nextOf();
+ const unsigned c_longsize = target.c.longsize;
+ const bool is64bit = global.params.is64bit;
+
+ switch (fmt)
+ {
+ case Format_n:
+ case Format_d: // pointer to int
+ if (!(t->ty == Tpointer && tnext->ty == Tint32))
+ errorScanfFormat(NULL, slice, e, "int*", t);
+ break;
+
+ case Format_hhn:
+ case Format_hhd: // pointer to signed char
+ if (!(t->ty == Tpointer && tnext->ty == Tint16))
+ errorScanfFormat(NULL, slice, e, "byte*", t);
+ break;
+
+ case Format_hn:
+ case Format_hd: // pointer to short
+ if (!(t->ty == Tpointer && tnext->ty == Tint16))
+ errorScanfFormat(NULL, slice, e, "short*", t);
+ break;
+
+ case Format_ln:
+ case Format_ld: // pointer to long int
+ if (!(t->ty == Tpointer && tnext->isintegral() && tnext->size() == c_longsize))
+ errorScanfFormat(NULL, slice, e, (c_longsize == 4 ? "int*" : "long*"), t);
+ break;
+
+ case Format_lln:
+ case Format_lld: // pointer to long long int
+ if (!(t->ty == Tpointer && tnext->ty == Tint64))
+ errorScanfFormat(NULL, slice, e, "long*", t);
+ break;
+
+ case Format_jn:
+ case Format_jd: // pointer to intmax_t
+ if (!(t->ty == Tpointer && tnext->ty == Tint64))
+ errorScanfFormat(NULL, slice, e, "core.stdc.stdint.intmax_t*", t);
+ break;
+
+ case Format_zn:
+ case Format_zd: // pointer to size_t
+ if (!(t->ty == Tpointer && tnext->ty == (is64bit ? Tuns64 : Tuns32)))
+ errorScanfFormat(NULL, slice, e, "size_t*", t);
+ break;
+
+ case Format_tn:
+ case Format_td: // pointer to ptrdiff_t
+ if (!(t->ty == Tpointer && tnext->ty == (is64bit ? Tint64 : Tint32)))
+ errorScanfFormat(NULL, slice, e, "ptrdiff_t*", t);
+ break;
+
+ case Format_u: // pointer to unsigned int
+ if (!(t->ty == Tpointer && tnext->ty == Tuns32))
+ errorScanfFormat(NULL, slice, e, "uint*", t);
+ break;
+
+ case Format_hhu: // pointer to unsigned char
+ if (!(t->ty == Tpointer && tnext->ty == Tuns8))
+ errorScanfFormat(NULL, slice, e, "ubyte*", t);
+ break;
+
+ case Format_hu: // pointer to unsigned short int
+ if (!(t->ty == Tpointer && tnext->ty == Tuns16))
+ errorScanfFormat(NULL, slice, e, "ushort*", t);
+ break;
+
+ case Format_lu: // pointer to unsigned long int
+ if (!(t->ty == Tpointer && tnext->ty == (is64bit ? Tuns64 : Tuns32)))
+ errorScanfFormat(NULL, slice, e, (c_longsize == 4 ? "uint*" : "ulong*"), t);
+ break;
+
+ case Format_llu: // pointer to unsigned long long int
+ if (!(t->ty == Tpointer && tnext->ty == Tuns64))
+ errorScanfFormat(NULL, slice, e, "ulong*", t);
+ break;
+
+ case Format_ju: // pointer to uintmax_t
+ if (!(t->ty == Tpointer && tnext->ty == (is64bit ? Tuns64 : Tuns32)))
+ errorScanfFormat(NULL, slice, e, "ulong*", t);
+ break;
+
+ case Format_g: // pointer to float
+ if (!(t->ty == Tpointer && tnext->ty == Tfloat32))
+ errorScanfFormat(NULL, slice, e, "float*", t);
+ break;
+
+ case Format_lg: // pointer to double
+ if (!(t->ty == Tpointer && tnext->ty == Tfloat64))
+ errorScanfFormat(NULL, slice, e, "double*", t);
+ break;
+
+ case Format_Lg: // pointer to long double
+ if (!(t->ty == Tpointer && tnext->ty == Tfloat80))
+ errorScanfFormat(NULL, slice, e, "real*", t);
+ break;
+
+ case Format_GNU_a:
+ case Format_GNU_m:
+ case Format_c:
+ case Format_s: // pointer to char string
+ if (!(t->ty == Tpointer && (tnext->ty == Tchar || tnext->ty == Tint8 || tnext->ty == Tuns8)))
+ errorScanfFormat(NULL, slice, e, "char*", t);
+ break;
+
+ case Format_lc:
+ case Format_ls: // pointer to wchar_t string
+ {
+ if (!(t->ty == Tpointer && tnext == target.c.twchar_t))
+ errorScanfFormat(NULL, slice, e, "wchar_t*", t);
+ break;
+ }
+ case Format_p: // double pointer
+ if (!(t->ty == Tpointer && tnext->ty == Tpointer))
+ errorScanfFormat(NULL, slice, e, "void**", t);
+ break;
+
+ case Format_error:
+ deprecation(loc, "format specifier `\"%.*s\"` is invalid", (int)slice.length, slice.ptr);
+ break;
+
+ case Format_percent:
+ default:
+ assert(0);
+ }
+ }
+ return false;
+}
@@ -806,6 +806,14 @@ public:
writeBasicType(t, 'D', 'n');
}
+ void visit(TypeNoreturn *t)
+ {
+ if (t->isImmutable() || t->isShared())
+ return error(t);
+
+ writeBasicType(t, 0, 'v'); // mangle like `void`
+ }
+
void visit(TypeBasic *t)
{
if (t->isImmutable() || t->isShared())
@@ -1012,7 +1020,7 @@ public:
if (t->isImmutable() || t->isShared())
return error(t);
- /* __c_(u)long(long) get special mangling
+ /* __c_(u)long(long) and others get special mangling
*/
Identifier *id = t->sym->ident;
//printf("enum id = '%s'\n", id->toChars());
@@ -1020,10 +1028,18 @@ public:
return writeBasicType(t, 0, 'l');
else if (id == Id::__c_ulong)
return writeBasicType(t, 0, 'm');
+ else if (id == Id::__c_wchar_t)
+ return writeBasicType(t, 0, 'w');
else if (id == Id::__c_longlong)
return writeBasicType(t, 0, 'x');
else if (id == Id::__c_ulonglong)
return writeBasicType(t, 0, 'y');
+ else if (id == Id::__c_complex_float)
+ return writeBasicType(t, 'C', 'f');
+ else if (id == Id::__c_complex_double)
+ return writeBasicType(t, 'C', 'd');
+ else if (id == Id::__c_complex_real)
+ return writeBasicType(t, 'C', 'e');
doSymbol(t);
}
@@ -162,7 +162,7 @@ const char *CTFEExp::toChars()
switch (op)
{
case TOKcantexp: return "<cant>";
- case TOKvoidexp: return "<void>";
+ case TOKvoidexp: return "cast(void)0";
case TOKbreak: return "<break>";
case TOKcontinue: return "<continue>";
case TOKgoto: return "<goto>";
@@ -26,6 +26,7 @@
FuncDeclaration *isFuncAddress(Expression *e, bool *hasOverloads = NULL);
bool isCommutative(TOK op);
MOD MODmerge(MOD mod1, MOD mod2);
+void toAutoQualChars(const char **result, Type *t1, Type *t2);
/* ==================== implicitCast ====================== */
@@ -90,8 +91,10 @@ Expression *implicitCastTo(Expression *e, Scope *sc, Type *t)
//printf("type %p ty %d deco %p\n", type, type->ty, type->deco);
//type = type->semantic(loc, sc);
//printf("type %s t %s\n", type->deco, t->deco);
+ const char *ts[2];
+ toAutoQualChars(ts, e->type, t);
e->error("cannot implicitly convert expression (%s) of type %s to %s",
- e->toChars(), e->type->toChars(), t->toChars());
+ e->toChars(), ts[0], ts[1]);
}
}
result = new ErrorExp();
@@ -277,15 +277,10 @@ Scope *ClassDeclaration::newScope(Scope *sc)
Scope *sc2 = AggregateDeclaration::newScope(sc);
if (isCOMclass())
{
- if (global.params.isWindows)
- sc2->linkage = LINKwindows;
- else
- {
- /* This enables us to use COM objects under Linux and
- * work with things like XPCOM
- */
- sc2->linkage = LINKc;
- }
+ /* This enables us to use COM objects under Linux and
+ * work with things like XPCOM
+ */
+ sc2->linkage = target.systemLinkage();
}
return sc2;
}
@@ -491,9 +486,10 @@ void ClassDeclaration::finalizeSize()
assert(baseClass->sizeok == SIZEOKdone);
alignsize = baseClass->alignsize;
- structsize = baseClass->structsize;
- if (isCPPclass() && global.params.isWindows)
- structsize = (structsize + alignsize - 1) & ~(alignsize - 1);
+ if (classKind == ClassKind::cpp)
+ structsize = target.cpp.derivedClassOffset(baseClass);
+ else
+ structsize = baseClass->structsize;
}
else if (isInterfaceDeclaration())
{
@@ -118,7 +118,7 @@ struct Match
FuncDeclaration *anyf; // pick a func, any func, to use for error recovery
};
-void functionResolve(Match *m, Dsymbol *fd, Loc loc, Scope *sc, Objects *tiargs, Type *tthis, Expressions *fargs);
+void functionResolve(Match *m, Dsymbol *fd, Loc loc, Scope *sc, Objects *tiargs, Type *tthis, Expressions *fargs, const char **pMessage = NULL);
int overloadApply(Dsymbol *fstart, void *param, int (*fp)(void *, Dsymbol *));
void aliasSemantic(AliasDeclaration *ds, Scope *sc);
@@ -551,6 +551,8 @@ void builtin_init();
#define FUNCFLAGreturnInprocess 0x10 // working on inferring 'return' for parameters
#define FUNCFLAGinlineScanned 0x20 // function has been scanned for inline possibilities
#define FUNCFLAGinferScope 0x40 // infer 'scope' for parameters
+#define FUNCFLAGprintf 0x200 // is a printf-like function
+#define FUNCFLAGscanf 0x400 // is a scanf-like function
class FuncDeclaration : public Declaration
{
@@ -22,6 +22,19 @@
#include "declaration.h"
#include "init.h"
+bool isSpecialEnumIdent(const Identifier *ident)
+{
+ return ident == Id::__c_long ||
+ ident == Id::__c_ulong ||
+ ident == Id::__c_longlong ||
+ ident == Id::__c_ulonglong ||
+ ident == Id::__c_long_double ||
+ ident == Id::__c_wchar_t ||
+ ident == Id::__c_complex_float ||
+ ident == Id::__c_complex_double ||
+ ident == Id::__c_complex_real;
+}
+
/********************************* EnumDeclaration ****************************/
EnumDeclaration::EnumDeclaration(Loc loc, Identifier *id, Type *memtype)
@@ -187,11 +200,7 @@ Lerrors:
*/
bool EnumDeclaration::isSpecial() const
{
- return (ident == Id::__c_long ||
- ident == Id::__c_ulong ||
- ident == Id::__c_longlong ||
- ident == Id::__c_ulonglong ||
- ident == Id::__c_long_double) && memtype;
+ return isSpecialEnumIdent(ident) && memtype;
}
Expression *EnumDeclaration::getDefaultValue(Loc loc)
@@ -161,37 +161,75 @@ void Import::load(Scope *sc)
if (mod && !mod->importedFrom)
mod->importedFrom = sc ? sc->_module->importedFrom : Module::rootModule;
if (!pkg)
- pkg = mod;
+ {
+ if (mod && mod->isPackageFile)
+ {
+ // one level depth package.d file (import pkg; ./pkg/package.d)
+ // it's necessary to use the wrapping Package already created
+ pkg = mod->pkg;
+ }
+ else
+ pkg = mod;
+ }
//printf("-Import::load('%s'), pkg = %p\n", toChars(), pkg);
}
void Import::importAll(Scope *sc)
{
- if (!mod)
+ if (mod) return; // Already done
+ load(sc);
+ if (!mod) return; // Failed
+
+ if (sc->stc & STCstatic)
+ isstatic = true;
+ mod->importAll(NULL);
+ if (mod->md && mod->md->isdeprecated)
{
- load(sc);
- if (mod) // if successfully loaded module
- {
- mod->importAll(NULL);
-
- if (mod->md && mod->md->isdeprecated)
- {
- Expression *msg = mod->md->msg;
- if (StringExp *se = msg ? msg->toStringExp() : NULL)
- mod->deprecation(loc, "is deprecated - %s", se->string);
- else
- mod->deprecation(loc, "is deprecated");
- }
+ Expression *msg = mod->md->msg;
+ if (StringExp *se = msg ? msg->toStringExp() : NULL)
+ mod->deprecation(loc, "is deprecated - %s", se->string);
+ else
+ mod->deprecation(loc, "is deprecated");
+ }
+ if (sc->explicitProtection)
+ protection = sc->protection;
+ if (!isstatic && !aliasId && !names.length)
+ sc->scopesym->importScope(mod, protection);
+ // Enable access to pkgs/mod as soon as posible, because compiler
+ // can traverse them before the import gets semantic (Issue: 21501)
+ if (!aliasId && !names.length)
+ addPackageAccess(sc->scopesym);
+}
- if (sc->explicitProtection)
- protection = sc->protection;
- if (!isstatic && !aliasId && !names.length)
- {
- sc->scopesym->importScope(mod, protection);
- }
+/*******************************
+ * Mark the imported packages as accessible from the current
+ * scope. This access check is necessary when using FQN b/c
+ * we're using a single global package tree.
+ * https://issues.dlang.org/show_bug.cgi?id=313
+ */
+void Import::addPackageAccess(ScopeDsymbol *scopesym)
+{
+ //printf("Import::addPackageAccess('%s') %p\n", toPrettyChars(), this);
+ if (packages)
+ {
+ // import a.b.c.d;
+ Package *p = pkg; // a
+ scopesym->addAccessiblePackage(p, protection);
+ for (size_t i = 1; i < packages->length; i++) // [b, c]
+ {
+ Identifier *id = (*packages)[i];
+ p = (Package *) p->symtab->lookup(id);
+ // https://issues.dlang.org/show_bug.cgi?id=17991
+ // An import of truly empty file/package can happen
+ // https://issues.dlang.org/show_bug.cgi?id=20151
+ // Package in the path conflicts with a module name
+ if (p == NULL)
+ return;
+ scopesym->addAccessiblePackage(p, protection);
}
}
+ scopesym->addAccessiblePackage(mod, protection); // d
}
Dsymbol *Import::toAlias()
@@ -82,6 +82,8 @@ void initTypeMangle()
mangleChar[Treturn] = "@";
mangleChar[Tvector] = "@";
mangleChar[Ttraits] = "@";
+ mangleChar[Tmixin] = "@";
+ mangleChar[Tnoreturn] = "@"; // becomes 'Nn'
mangleChar[Tnull] = "n"; // same as TypeNone
@@ -150,7 +152,7 @@ public:
* using upper case letters for all digits but the last digit which uses
* a lower case letter.
* The decoder has to look up the referenced position to determine
- * whether the back reference is an identifer (starts with a digit)
+ * whether the back reference is an identifier (starts with a digit)
* or a type (starts with a letter).
*
* Params:
@@ -414,6 +416,11 @@ public:
visit((Type *)t);
}
+ void visit(TypeNoreturn *)
+ {
+ buf->writestring("Nn");
+ }
+
////////////////////////////////////////////////////////////////////////////
void mangleDecl(Declaration *sthis)
@@ -1085,3 +1092,31 @@ void mangleToBuffer(TemplateInstance *ti, OutBuffer *buf)
Mangler v(buf);
v.mangleTemplateInstance(ti);
}
+
+/**********************************************
+ * Convert a string representing a type (the deco) and
+ * return its equivalent Type.
+ * Params:
+ * deco = string containing the deco
+ * Returns:
+ * null for failed to convert
+ * Type for succeeded
+ */
+
+Type *decoToType(const char *deco)
+{
+ if (!deco)
+ return NULL;
+
+ //printf("decoToType(): %s\n", deco)
+ if (StringValue *sv = Type::stringtable.lookup(deco, strlen(deco)))
+ {
+ if (sv->ptrvalue)
+ {
+ Type *t = (Type *)sv->ptrvalue;
+ assert(t->deco);
+ return t;
+ }
+ }
+ return NULL;
+}
@@ -52,6 +52,7 @@ Module::Module(const char *filename, Identifier *ident, int doDocComment, int do
members = NULL;
isDocFile = 0;
isPackageFile = false;
+ pkg = NULL;
needmoduleinfo = 0;
selfimports = 0;
rootimports = 0;
@@ -685,15 +686,27 @@ Module *Module::parse()
*
* To avoid the conflict:
* 1. If preceding package name insertion had occurred by Package::resolve,
- * later package.d loading will change Package::isPkgMod to PKGmodule and set Package::mod.
+ * reuse the previous wrapping 'Package' if it exists
* 2. Otherwise, 'package.d' wrapped by 'Package' is inserted to the internal tree in here.
+ *
+ * Then change Package::isPkgMod to PKGmodule and set Package::mod.
+ *
+ * Note that the 'wrapping Package' is the Package that contains package.d and other submodules,
+ * the one inserted to the symbol table.
*/
- Package *p = new Package(ident);
+ Dsymbol *ps = dst->lookup(ident);
+ Package *p = ps ? ps->isPackage() : NULL;
+ if (p == NULL)
+ {
+ p = new Package(ident);
+ p->tag = this->tag; // reuse the same package tag
+ p->symtab = new DsymbolTable();
+ }
+ this->tag= p->tag; // reuse the 'older' package tag
+ this->pkg = p;
p->parent = this->parent;
p->isPkgMod = PKGmodule;
p->mod = this;
- p->tag = this->tag; // reuse the same package tag
- p->symtab = new DsymbolTable();
s = p;
}
if (!dst->insert(s))
@@ -720,15 +733,9 @@ Module *Module::parse()
}
else if (Package *pkg = prev->isPackage())
{
- if (pkg->isPkgMod == PKGunknown && isPackageFile)
- {
- /* If the previous inserted Package is not yet determined as package.d,
- * link it to the actual module.
- */
- pkg->isPkgMod = PKGmodule;
- pkg->mod = this;
- pkg->tag = this->tag; // reuse the same package tag
- }
+ // 'package.d' loaded after a previous 'Package' insertion
+ if (isPackageFile)
+ amodules.push(this); // Add to global array of all modules
else
error(md ? md->loc : loc, "from file %s conflicts with package name %s",
srcname, pkg->toChars());
@@ -24,6 +24,7 @@
#include "aggregate.h"
#include "module.h"
#include "id.h"
+#include "target.h"
#include "template.h"
Scope *Scope::freelist = NULL;
@@ -155,7 +156,8 @@ Scope *Scope::push()
s->nofree = 0;
s->fieldinit = saveFieldInit();
s->flags = (flags & (SCOPEcontract | SCOPEdebug | SCOPEctfe | SCOPEcompile | SCOPEconstraint |
- SCOPEnoaccesscheck | SCOPEignoresymbolvisibility));
+ SCOPEnoaccesscheck | SCOPEignoresymbolvisibility |
+ SCOPEprintf | SCOPEscanf));
s->lastdc = NULL;
assert(this != s);
@@ -637,7 +639,7 @@ const char *Scope::search_correct_C(Identifier *ident)
else if (ident == Id::C_unsigned)
tok = TOKuns32;
else if (ident == Id::C_wchar_t)
- tok = global.params.isWindows ? TOKwchar : TOKdchar;
+ tok = target.c.twchar_t->ty == Twchar ? TOKwchar : TOKdchar;
else
return NULL;
return Token::toChars(tok);
@@ -515,7 +515,7 @@ Dsymbol *Dsymbol::search_correct(Identifier *ident)
* Returns:
* symbol found, NULL if not
*/
-Dsymbol *Dsymbol::searchX(Loc loc, Scope *sc, RootObject *id)
+Dsymbol *Dsymbol::searchX(Loc loc, Scope *sc, RootObject *id, int flags)
{
//printf("Dsymbol::searchX(this=%p,%s, ident='%s')\n", this, toChars(), ident->toChars());
Dsymbol *s = toAlias();
@@ -533,7 +533,7 @@ Dsymbol *Dsymbol::searchX(Loc loc, Scope *sc, RootObject *id)
switch (id->dyncast())
{
case DYNCAST_IDENTIFIER:
- sm = s->search(loc, (Identifier *)id);
+ sm = s->search(loc, (Identifier *)id, flags);
break;
case DYNCAST_DSYMBOL:
@@ -1801,31 +1801,3 @@ bool Prot::operator==(const Prot& other) const
}
return false;
}
-
-/**
- * Checks if parent defines different access restrictions than this one.
- *
- * Params:
- * parent = protection attribute for scope that hosts this one
- *
- * Returns:
- * 'true' if parent is already more restrictive than this one and thus
- * no differentiation is needed.
- */
-bool Prot::isSubsetOf(const Prot& parent) const
-{
- if (this->kind != parent.kind)
- return false;
-
- if (this->kind == Prot::package_)
- {
- if (!this->pkg)
- return true;
- if (!parent.pkg)
- return false;
- if (parent.pkg->isAncestorPackageOf(this->pkg))
- return true;
- }
-
- return true;
-}
@@ -107,7 +107,6 @@ struct Prot
bool isMoreRestrictiveThan(const Prot other) const;
bool operator==(const Prot& other) const;
- bool isSubsetOf(const Prot& other) const;
};
// in hdrgen.c
@@ -207,7 +206,7 @@ public:
virtual void importAll(Scope *sc);
virtual Dsymbol *search(const Loc &loc, Identifier *ident, int flags = IgnoreNone);
Dsymbol *search_correct(Identifier *id);
- Dsymbol *searchX(Loc loc, Scope *sc, RootObject *id);
+ Dsymbol *searchX(Loc loc, Scope *sc, RootObject *id, int flags);
virtual bool overloadInsert(Dsymbol *s);
virtual d_uns64 size(Loc loc);
virtual bool isforwardRef();
@@ -42,6 +42,8 @@ VarDeclaration *copyToTemp(StorageClass stc, const char *name, Expression *e);
Initializer *inferType(Initializer *init, Scope *sc);
void MODtoBuffer(OutBuffer *buf, MOD mod);
bool reliesOnTident(Type *t, TemplateParameters *tparams = NULL, size_t iStart = 0);
+bool expressionsToString(OutBuffer &buf, Scope *sc, Expressions *exps);
+bool symbolIsVisible(Scope *sc, Dsymbol *s);
Objc *objc();
static unsigned setMangleOverride(Dsymbol *s, char *sym)
@@ -1098,22 +1100,7 @@ public:
scopesym->importScope(imp->mod, imp->protection);
}
- // Mark the imported packages as accessible from the current
- // scope. This access check is necessary when using FQN b/c
- // we're using a single global package tree. See Bugzilla 313.
- if (imp->packages)
- {
- // import a.b.c.d;
- Package *p = imp->pkg; // a
- scopesym->addAccessiblePackage(p, imp->protection);
- for (size_t i = 1; i < imp->packages->length; i++) // [b, c]
- {
- Identifier *id = (*imp->packages)[i];
- p = (Package *) p->symtab->lookup(id);
- scopesym->addAccessiblePackage(p, imp->protection);
- }
- }
- scopesym->addAccessiblePackage(imp->mod, imp->protection); // d
+ imp->addPackageAccess(scopesym);
}
dsymbolSemantic(imp->mod, NULL);
@@ -1130,8 +1117,12 @@ public:
{
AliasDeclaration *ad = imp->aliasdecls[i];
//printf("\tImport %s alias %s = %s, scope = %p\n", toPrettyChars(), imp->aliases[i]->toChars(), imp->names[i]->toChars(), ad->_scope);
- if (imp->mod->search(imp->loc, imp->names[i]))
+ Dsymbol *sym = imp->mod->search(imp->loc, imp->names[i], IgnorePrivateImports);
+ if (sym)
{
+ if (!symbolIsVisible(sc, sym))
+ imp->mod->error(imp->loc, "member `%s` is not visible from module `%s`",
+ imp->names[i]->toChars(), sc->_module->toChars());
dsymbolSemantic(ad, sc);
// If the import declaration is in non-root module,
// analysis of the aliased symbol is deferred.
@@ -1141,7 +1132,7 @@ public:
{
Dsymbol *s = imp->mod->search_correct(imp->names[i]);
if (s)
- imp->mod->error(imp->loc, "import `%s` not found, did you mean %s `%s`?", imp->names[i]->toChars(), s->kind(), s->toChars());
+ imp->mod->error(imp->loc, "import `%s` not found, did you mean %s `%s`?", imp->names[i]->toChars(), s->kind(), s->toPrettyChars());
else
imp->mod->error(imp->loc, "import `%s` not found", imp->names[i]->toChars());
ad->type = Type::terror;
@@ -1312,8 +1303,6 @@ public:
e = expressionSemantic(e, sc);
e = resolveProperties(sc, e);
sc = sc->endCTFE();
-
- // pragma(msg) is allowed to contain types as well as expressions
e = ctfeInterpretForPragmaMsg(e);
if (e->op == TOKerror)
{
@@ -1458,6 +1447,12 @@ public:
}
}
}
+ else if (pd->ident == Id::printf || pd->ident == Id::scanf)
+ {
+ if (pd->args && pd->args->length != 0)
+ pd->error("takes no argument");
+ goto Ldecl;
+ }
else if (global.params.ignoreUnsupportedPragmas)
{
if (global.params.verbose)
@@ -1547,13 +1542,14 @@ public:
Dsymbols *compileIt(CompileDeclaration *cd)
{
//printf("CompileDeclaration::compileIt(loc = %d) %s\n", cd->loc.linnum, cd->exp->toChars());
- StringExp *se = semanticString(sc, cd->exp, "argument to mixin");
- if (!se)
+ OutBuffer buf;
+ if (expressionsToString(buf, sc, cd->exps))
return NULL;
- se = se->toUTF8(sc);
unsigned errors = global.errors;
- Parser p(cd->loc, sc->_module, (utf8_t *)se->string, se->len, 0);
+ const size_t len = buf.length();
+ const char *str = buf.extractChars();
+ Parser p(cd->loc, sc->_module, (const utf8_t *)str, len, false);
p.nextToken();
Dsymbols *d = p.parseDeclDefs(0);
@@ -1562,7 +1558,7 @@ public:
if (p.token.value != TOKeof)
{
- cd->exp->error("incomplete mixin declaration (%s)", se->toChars());
+ cd->error("incomplete mixin declaration (%s)", str);
return NULL;
}
return d;
@@ -1637,7 +1633,7 @@ public:
Scope *sc = m->_scope; // see if already got one from importAll()
if (!sc)
{
- Scope::createGlobal(m); // create root scope
+ sc = Scope::createGlobal(m); // create root scope
}
//printf("Module = %p, linkage = %d\n", sc->scopesym, sc->linkage);
@@ -1735,7 +1731,7 @@ public:
// memtype is forward referenced, so try again later
ed->_scope = scx ? scx : sc->copy();
ed->_scope->setNoFree();
- ed->_scope->_module->addDeferredSemantic(ed);
+ Module::addDeferredSemantic(ed);
Module::dprogress = dprogress_save;
//printf("\tdeferring %s\n", ed->toChars());
ed->semanticRun = PASSinit;
@@ -2233,7 +2229,7 @@ public:
//printf("forward reference - deferring\n");
tm->_scope = scx ? scx : sc->copy();
tm->_scope->setNoFree();
- tm->_scope->_module->addDeferredSemantic(tm);
+ Module::addDeferredSemantic(tm);
return;
}
@@ -2457,6 +2453,23 @@ public:
ns->semanticRun = PASSsemanticdone;
}
+
+private:
+ static bool isPointerToChar(Parameter *p)
+ {
+ if (TypePointer *tptr = p->type->isTypePointer())
+ {
+ return tptr->next->ty == Tchar;
+ }
+ return false;
+ }
+
+ static bool isVa_list(Parameter *p, FuncDeclaration *funcdecl, Scope *sc)
+ {
+ return p->type->equals(target.va_listType(funcdecl->loc, sc));
+ }
+
+public:
void funcDeclarationSemantic(FuncDeclaration *funcdecl)
{
TypeFunction *f;
@@ -2771,6 +2784,45 @@ public:
if (funcdecl->isAbstract() && funcdecl->isFinalFunc())
funcdecl->error("cannot be both final and abstract");
+ if (const unsigned pors = sc->flags & (SCOPEprintf | SCOPEscanf))
+ {
+ /* printf/scanf-like functions must be of the form:
+ * extern (C/C++) T printf([parameters...], const(char)* format, ...);
+ * or:
+ * extern (C/C++) T vprintf([parameters...], const(char)* format, va_list);
+ */
+ const size_t nparams = f->parameterList.length();
+ if ((f->linkage == LINKc || f->linkage == LINKcpp) &&
+
+ ((f->parameterList.varargs == VARARGvariadic &&
+ nparams >= 1 &&
+ isPointerToChar(f->parameterList[nparams - 1])) ||
+ (f->parameterList.varargs == VARARGnone &&
+ nparams >= 2 &&
+ isPointerToChar(f->parameterList[nparams - 2]) &&
+ isVa_list(f->parameterList[nparams - 1], funcdecl, sc))
+ )
+ )
+ {
+ funcdecl->flags |= (pors == SCOPEprintf) ? FUNCFLAGprintf : FUNCFLAGscanf;
+ }
+ else
+ {
+ const char *p = (pors == SCOPEprintf ? Id::printf : Id::scanf)->toChars();
+ if (f->parameterList.varargs == VARARGvariadic)
+ {
+ funcdecl->error("`pragma(%s)` functions must be `extern(C) %s %s([parameters...], const(char)*, ...)`"
+ " not `%s`",
+ p, f->next->toChars(), funcdecl->toChars(), funcdecl->type->toChars());
+ }
+ else
+ {
+ funcdecl->error("`pragma(%s)` functions must be `extern(C) %s %s([parameters...], const(char)*, va_list)`",
+ p, f->next->toChars(), funcdecl->toChars());
+ }
+ }
+ }
+
id = parent->isInterfaceDeclaration();
if (id)
{
@@ -3831,7 +3883,7 @@ public:
sd->_scope = scx ? scx : sc->copy();
sd->_scope->setNoFree();
- sd->_scope->_module->addDeferredSemantic(sd);
+ Module::addDeferredSemantic(sd);
//printf("\tdeferring %s\n", sd->toChars());
return;
@@ -4079,7 +4131,7 @@ public:
{
//printf("\ttry later, forward reference of base class %s\n", tc->sym->toChars());
if (tc->sym->_scope)
- tc->sym->_scope->_module->addDeferredSemantic(tc->sym);
+ Module::addDeferredSemantic(tc->sym);
cldec->baseok = BASEOKnone;
}
L7: ;
@@ -4131,7 +4183,7 @@ public:
{
//printf("\ttry later, forward reference of base %s\n", tc->sym->toChars());
if (tc->sym->_scope)
- tc->sym->_scope->_module->addDeferredSemantic(tc->sym);
+ Module::addDeferredSemantic(tc->sym);
cldec->baseok = BASEOKnone;
}
i++;
@@ -4141,7 +4193,7 @@ public:
// Forward referencee of one or more bases, try again later
cldec->_scope = scx ? scx : sc->copy();
cldec->_scope->setNoFree();
- cldec->_scope->_module->addDeferredSemantic(cldec);
+ Module::addDeferredSemantic(cldec);
//printf("\tL%d semantic('%s') failed due to forward references\n", __LINE__, cldec->toChars());
return;
}
@@ -4254,8 +4306,8 @@ public:
cldec->_scope = scx ? scx : sc->copy();
cldec->_scope->setNoFree();
if (tc->sym->_scope)
- tc->sym->_scope->_module->addDeferredSemantic(tc->sym);
- cldec->_scope->_module->addDeferredSemantic(cldec);
+ Module::addDeferredSemantic(tc->sym);
+ Module::addDeferredSemantic(cldec);
//printf("\tL%d semantic('%s') failed due to forward references\n", __LINE__, cldec->toChars());
return;
}
@@ -4359,7 +4411,7 @@ public:
cldec->_scope = scx ? scx : sc->copy();
cldec->_scope->setNoFree();
- cldec->_scope->_module->addDeferredSemantic(cldec);
+ Module::addDeferredSemantic(cldec);
//printf("\tdeferring %s\n", cldec->toChars());
return;
}
@@ -4628,7 +4680,7 @@ public:
{
//printf("\ttry later, forward reference of base %s\n", tc->sym->toChars());
if (tc->sym->_scope)
- tc->sym->_scope->_module->addDeferredSemantic(tc->sym);
+ Module::addDeferredSemantic(tc->sym);
idec->baseok = BASEOKnone;
}
i++;
@@ -4638,7 +4690,7 @@ public:
// Forward referencee of one or more bases, try again later
idec->_scope = scx ? scx : sc->copy();
idec->_scope->setNoFree();
- idec->_scope->_module->addDeferredSemantic(idec);
+ Module::addDeferredSemantic(idec);
return;
}
idec->baseok = BASEOKdone;
@@ -4682,8 +4734,8 @@ public:
idec->_scope = scx ? scx : sc->copy();
idec->_scope->setNoFree();
if (tc->sym->_scope)
- tc->sym->_scope->_module->addDeferredSemantic(tc->sym);
- idec->_scope->_module->addDeferredSemantic(idec);
+ Module::addDeferredSemantic(tc->sym);
+ Module::addDeferredSemantic(idec);
return;
}
}
@@ -5335,6 +5387,7 @@ void aliasSemantic(AliasDeclaration *ds, Scope *sc)
ds->userAttribDecl = sc->userAttribDecl;
// TypeTraits needs to know if it's located in an AliasDeclaration
+ const unsigned oldflags = sc->flags;
sc->flags |= SCOPEalias;
if (ds->aliassym)
@@ -5345,7 +5398,7 @@ void aliasSemantic(AliasDeclaration *ds, Scope *sc)
{
if (fd && fd->semanticRun >= PASSsemanticdone)
{
- sc->flags &= ~SCOPEalias;
+ sc->flags = oldflags;
return;
}
@@ -5361,13 +5414,13 @@ void aliasSemantic(AliasDeclaration *ds, Scope *sc)
ds->aliassym = NULL;
ds->type = Type::terror;
}
- sc->flags &= ~SCOPEalias;
+ sc->flags = oldflags;
return;
}
if (ds->aliassym->isTemplateInstance())
dsymbolSemantic(ds->aliassym, sc);
- sc->flags &= ~SCOPEalias;
+ sc->flags = oldflags;
return;
}
ds->inuse = 1;
@@ -5472,7 +5525,7 @@ void aliasSemantic(AliasDeclaration *ds, Scope *sc)
if (!ds->overloadInsert(sx))
ScopeDsymbol::multiplyDefined(Loc(), sx, ds);
}
- sc->flags &= ~SCOPEalias;
+ sc->flags = oldflags;
}
@@ -156,17 +156,14 @@ Dsymbol *getDsymbol(RootObject *oarg)
if (ea)
{
// Try to convert Expression to symbol
- if (ea->op == TOKvar)
- sa = ((VarExp *)ea)->var;
- else if (ea->op == TOKfunction)
- {
- if (((FuncExp *)ea)->td)
- sa = ((FuncExp *)ea)->td;
- else
- sa = ((FuncExp *)ea)->fd;
- }
- else if (ea->op == TOKtemplate)
- sa = ((TemplateExp *)ea)->td;
+ if (VarExp *ve = ea->isVarExp())
+ sa = ve->var;
+ else if (FuncExp *fe = ea->isFuncExp())
+ sa = fe->td ? (Dsymbol *)fe->td : (Dsymbol *)fe->fd;
+ else if (TemplateExp *te = ea->isTemplateExp())
+ sa = te->td;
+ else if (ScopeExp *se = ea->isScopeExp())
+ sa = se->sds;
else
sa = NULL;
}
@@ -536,6 +533,7 @@ TemplateDeclaration::TemplateDeclaration(Loc loc, Identifier *id,
this->isstatic = true;
this->previous = NULL;
this->protection = Prot(Prot::undefined);
+ this->inuse = 0;
this->instances = NULL;
// Compute in advance for Ddoc's use
@@ -770,7 +768,9 @@ MATCH TemplateDeclaration::matchWithInstance(Scope *sc, TemplateInstance *ti,
Declaration *sparam;
//printf("\targument [%d]\n", i);
+ inuse++;
m2 = tp->matchArg(ti->loc, paramscope, ti->tiargs, i, parameters, dedtypes, &sparam);
+ inuse--;
//printf("\tm2 = %d\n", m2);
if (m2 == MATCHnomatch)
@@ -1397,7 +1397,9 @@ MATCH TemplateDeclaration::deduceFunctionTemplateMatch(
}
else
{
+ inuse++;
oded = tparam->defaultArg(instLoc, paramscope);
+ inuse--;
if (oded)
(*dedargs)[i] = declareParameter(paramscope, tparam, oded);
}
@@ -1771,7 +1773,9 @@ Lmatch:
}
else
{
+ inuse++;
oded = tparam->defaultArg(instLoc, paramscope);
+ inuse--;
if (!oded)
{
// if tuple parameter and
@@ -1997,18 +2001,19 @@ bool TemplateDeclaration::isOverloadable()
/*************************************************
* Given function arguments, figure out which template function
* to expand, and return matching result.
- * Input:
- * m matching result
- * dstart the root of overloaded function templates
- * loc instantiation location
- * sc instantiation scope
- * tiargs initial list of template arguments
- * tthis if !NULL, the 'this' pointer argument
- * fargs arguments to function
+ * Params:
+ * m = matching result
+ * dstart = the root of overloaded function templates
+ * loc = instantiation location
+ * sc = instantiation scope
+ * tiargs = initial list of template arguments
+ * tthis = if !NULL, the 'this' pointer argument
+ * fargs = arguments to function
+ * pMessage = address to store error message, or null
*/
void functionResolve(Match *m, Dsymbol *dstart, Loc loc, Scope *sc,
- Objects *tiargs, Type *tthis, Expressions *fargs)
+ Objects *tiargs, Type *tthis, Expressions *fargs, const char **pMessage)
{
struct ParamDeduce
{
@@ -2018,6 +2023,7 @@ void functionResolve(Match *m, Dsymbol *dstart, Loc loc, Scope *sc,
Type *tthis;
Objects *tiargs;
Expressions *fargs;
+ const char **pMessage;
// result
Match *m;
int property; // 0: unintialized
@@ -2093,7 +2099,7 @@ void functionResolve(Match *m, Dsymbol *dstart, Loc loc, Scope *sc,
else
return 0; // MATCHnomatch
}
- MATCH mfa = tf->callMatch(tthis_fd, fargs);
+ MATCH mfa = tf->callMatch(tthis_fd, fargs, 0, pMessage);
//printf("test1: mfa = %d\n", mfa);
if (mfa > MATCHnomatch)
{
@@ -2180,8 +2186,12 @@ void functionResolve(Match *m, Dsymbol *dstart, Loc loc, Scope *sc,
int applyTemplate(TemplateDeclaration *td)
{
//printf("applyTemplate()\n");
- // skip duplicates
- if (td == td_best)
+ if (td->inuse)
+ {
+ td->error(loc, "recursive template expansion");
+ return 1;
+ }
+ if (td == td_best) // skip duplicates
return 0;
if (!sc)
@@ -2431,6 +2441,7 @@ void functionResolve(Match *m, Dsymbol *dstart, Loc loc, Scope *sc,
p.tthis = tthis;
p.tiargs = tiargs;
p.fargs = fargs;
+ p.pMessage = pMessage;
// result
p.m = m;
@@ -5165,6 +5176,16 @@ MATCH TemplateAliasParameter::matchArg(Scope *sc, RootObject *oarg,
* template X(T) {} // T => sa
*/
}
+ else if (ta && ta->ty != Tident)
+ {
+ /* Match any type that's not a TypeIdentifier to alias parameters,
+ * but prefer type parameter.
+ * template X(alias a) { } // a == ta
+ *
+ * TypeIdentifiers are excluded because they might be not yet resolved aliases.
+ */
+ m = MATCHconvert;
+ }
else
goto Lnomatch;
}
@@ -5485,12 +5506,15 @@ RootObject *TemplateValueParameter::defaultArg(Loc instLoc, Scope *sc)
if (e)
{
e = e->syntaxCopy();
+ unsigned olderrs = global.errors;
if ((e = expressionSemantic(e, sc)) == NULL)
return NULL;
if ((e = resolveProperties(sc, e)) == NULL)
return NULL;
e = e->resolveLoc(instLoc, sc); // use the instantiated loc
e = e->optimize(WANTvalue);
+ if (global.errors != olderrs)
+ e = new ErrorExp();
}
return e;
}
@@ -6049,6 +6073,7 @@ bool TemplateInstance::semanticTiargs(Loc loc, Scope *sc, Objects *tiargs, int f
if (ta)
{
//printf("type %s\n", ta->toChars());
+
// It might really be an Expression or an Alias
ta->resolve(loc, sc, &ea, &ta, &sa, (flags & 1) != 0);
if (ea) goto Lexpr;
@@ -6270,6 +6295,7 @@ bool TemplateInstance::findBestMatch(Scope *sc, Expressions *fargs)
}
unsigned errs = global.errors;
+ TemplateDeclaration *td_last = NULL;
struct ParamBest
{
@@ -6291,7 +6317,11 @@ bool TemplateInstance::findBestMatch(Scope *sc, Expressions *fargs)
TemplateDeclaration *td = s->isTemplateDeclaration();
if (!td)
return 0;
-
+ if (td->inuse)
+ {
+ td->error(ti->loc, "recursive template expansion");
+ return 1;
+ }
if (td == td_best) // skip duplicates
return 0;
@@ -6349,8 +6379,6 @@ bool TemplateInstance::findBestMatch(Scope *sc, Expressions *fargs)
/* Since there can be multiple TemplateDeclaration's with the same
* name, look for the best match.
*/
- TemplateDeclaration *td_last = NULL;
-
OverloadSet *tovers = tempdecl->isOverloadSet();
size_t overs_dim = tovers ? tovers->a.length : 1;
for (size_t oi = 0; oi < overs_dim; oi++)
@@ -6359,7 +6387,9 @@ bool TemplateInstance::findBestMatch(Scope *sc, Expressions *fargs)
p.td_best = NULL;
p.td_ambig = NULL;
p.m_best = MATCHnomatch;
- overloadApply(tovers ? tovers->a[oi] : tempdecl, &p, &ParamBest::fp);
+
+ Dsymbol *dstart = tovers ? tovers->a[oi] : tempdecl;
+ overloadApply(dstart, &p, &ParamBest::fp);
if (p.td_ambig)
{
@@ -6481,8 +6511,11 @@ bool TemplateInstance::needsTypeInference(Scope *sc, int flag)
{
TemplateDeclaration *td = s->isTemplateDeclaration();
if (!td)
- {
return 0;
+ if (td->inuse)
+ {
+ td->error(ti->loc, "recursive template expansion");
+ return 1;
}
/* If any of the overloaded template declarations need inference,
@@ -7128,6 +7161,68 @@ void unSpeculative(Scope *sc, RootObject *o)
unSpeculative(sc, ti);
}
+/**
+ Returns: true if the instances' innards are discardable.
+
+ The idea of this function is to see if the template instantiation
+ can be 100% replaced with its eponymous member. All other members
+ can be discarded, even in the compiler to free memory (for example,
+ the template could be expanded in a region allocator, deemed trivial,
+ the end result copied back out independently and the entire region freed),
+ and can be elided entirely from the binary.
+
+ The current implementation affects code that generally looks like:
+
+ ---
+ template foo(args...) {
+ some_basic_type_or_string helper() { .... }
+ enum foo = helper();
+ }
+ ---
+
+ since it was the easiest starting point of implementation but it can and
+ should be expanded more later.
+*/
+static bool isDiscardable(TemplateInstance *ti)
+{
+ if (ti->aliasdecl == NULL)
+ return false;
+
+ VarDeclaration *v = ti->aliasdecl->isVarDeclaration();
+ if (v == NULL)
+ return false;
+
+ if (!(v->storage_class & STCmanifest))
+ return false;
+
+ // Currently only doing basic types here because it is the easiest proof-of-concept
+ // implementation with minimal risk of side effects, but it could likely be
+ // expanded to any type that already exists outside this particular instance.
+ if (!(v->type->equals(Type::tstring) || (v->type->isTypeBasic() != NULL)))
+ return false;
+
+ // Static ctors and dtors, even in an eponymous enum template, are still run,
+ // so if any of them are in here, we'd better not assume it is trivial lest
+ // we break useful code
+ for (size_t i = 0; i < ti->members->length; i++)
+ {
+ Dsymbol *member = (*ti->members)[i];
+ if (member->hasStaticCtorOrDtor())
+ return false;
+ if (member->isStaticDtorDeclaration())
+ return false;
+ if (member->isStaticCtorDeclaration())
+ return false;
+ }
+
+ // but if it passes through this gauntlet... it should be fine. D code will
+ // see only the eponymous member, outside stuff can never access it, even through
+ // reflection; the outside world ought to be none the wiser. Even dmd should be
+ // able to simply free the memory of everything except the final result.
+
+ return true;
+}
+
/***********************************************
* Returns true if this is not instantiated in non-root module, and
* is a part of non-speculative instantiatiation.
@@ -7137,38 +7232,6 @@ void unSpeculative(Scope *sc, RootObject *o)
*/
bool TemplateInstance::needsCodegen()
{
- // Now -allInst is just for the backward compatibility.
- if (global.params.allInst)
- {
- //printf("%s minst = %s, enclosing (%s)->isNonRoot = %d\n",
- // toPrettyChars(), minst ? minst->toChars() : NULL,
- // enclosing ? enclosing->toPrettyChars() : NULL, enclosing && enclosing->inNonRoot());
- if (enclosing)
- {
- // Bugzilla 14588: If the captured context is not a function
- // (e.g. class), the instance layout determination is guaranteed,
- // because the semantic/semantic2 pass will be executed
- // even for non-root instances.
- if (!enclosing->isFuncDeclaration())
- return true;
-
- // Bugzilla 14834: If the captured context is a function,
- // this excessive instantiation may cause ODR violation, because
- // -allInst and others doesn't guarantee the semantic3 execution
- // for that function.
-
- // If the enclosing is also an instantiated function,
- // we have to rely on the ancestor's needsCodegen() result.
- if (TemplateInstance *ti = enclosing->isInstantiated())
- return ti->needsCodegen();
-
- // Bugzilla 13415: If and only if the enclosing scope needs codegen,
- // this nested templates would also need code generation.
- return !enclosing->inNonRoot();
- }
- return true;
- }
-
if (!minst)
{
// If this is a speculative instantiation,
@@ -7185,6 +7248,10 @@ bool TemplateInstance::needsCodegen()
if (tinst && tinst->needsCodegen())
{
minst = tinst->minst; // cache result
+ if (global.params.allInst && minst)
+ {
+ return true;
+ }
assert(minst);
assert(minst->isRoot() || minst->rootImports());
return true;
@@ -7192,6 +7259,10 @@ bool TemplateInstance::needsCodegen()
if (tnext && (tnext->needsCodegen() || tnext->minst))
{
minst = tnext->minst; // cache result
+ if (global.params.allInst && minst)
+ {
+ return true;
+ }
assert(minst);
return minst->isRoot() || minst->rootImports();
}
@@ -7200,6 +7271,16 @@ bool TemplateInstance::needsCodegen()
return false;
}
+ if (global.params.allInst)
+ {
+ return true;
+ }
+
+ if (isDiscardable(this))
+ {
+ return false;
+ }
+
/* Even when this is reached to the codegen pass,
* a non-root nested template should not generate code,
* due to avoid ODR violation.
@@ -7221,14 +7302,7 @@ bool TemplateInstance::needsCodegen()
return false;
}
- /* The issue is that if the importee is compiled with a different -debug
- * setting than the importer, the importer may believe it exists
- * in the compiled importee when it does not, when the instantiation
- * is behind a conditional debug declaration.
- */
- // workaround for Bugzilla 11239
- if (global.params.useUnitTests ||
- global.params.debuglevel)
+ if (global.params.useUnitTests)
{
// Prefer instantiations from root modules, to maximize link-ability.
if (minst->isRoot())
@@ -43,110 +43,10 @@ VarDeclaration *copyToTemp(StorageClass stc, const char *name, Expression *e);
Expression *extractSideEffect(Scope *sc, const char *name, Expression **e0, Expression *e, bool alwaysCopy = false);
char *MODtoChars(MOD mod);
bool MODimplicitConv(MOD modfrom, MOD modto);
-MOD MODmerge(MOD mod1, MOD mod2);
void MODMatchToBuffer(OutBuffer *buf, unsigned char lhsMod, unsigned char rhsMod);
Expression *resolve(Loc loc, Scope *sc, Dsymbol *s, bool hasOverloads);
bool checkUnsafeAccess(Scope *sc, Expression *e, bool readonly, bool printmsg);
-
-/*************************************************************
- * Given var, we need to get the
- * right 'this' pointer if var is in an outer class, but our
- * existing 'this' pointer is in an inner class.
- * Input:
- * e1 existing 'this'
- * ad struct or class we need the correct 'this' for
- * var the specific member of ad we're accessing
- */
-
-Expression *getRightThis(Loc loc, Scope *sc, AggregateDeclaration *ad,
- Expression *e1, Declaration *var, int flag = 0)
-{
- //printf("\ngetRightThis(e1 = %s, ad = %s, var = %s)\n", e1->toChars(), ad->toChars(), var->toChars());
- L1:
- Type *t = e1->type->toBasetype();
- //printf("e1->type = %s, var->type = %s\n", e1->type->toChars(), var->type->toChars());
-
- /* If e1 is not the 'this' pointer for ad
- */
- if (ad &&
- !(t->ty == Tpointer && t->nextOf()->ty == Tstruct &&
- ((TypeStruct *)t->nextOf())->sym == ad)
- &&
- !(t->ty == Tstruct &&
- ((TypeStruct *)t)->sym == ad)
- )
- {
- ClassDeclaration *cd = ad->isClassDeclaration();
- ClassDeclaration *tcd = t->isClassHandle();
-
- /* e1 is the right this if ad is a base class of e1
- */
- if (!cd || !tcd ||
- !(tcd == cd || cd->isBaseOf(tcd, NULL))
- )
- {
- /* Only classes can be inner classes with an 'outer'
- * member pointing to the enclosing class instance
- */
- if (tcd && tcd->isNested())
- {
- /* e1 is the 'this' pointer for an inner class: tcd.
- * Rewrite it as the 'this' pointer for the outer class.
- */
-
- e1 = new DotVarExp(loc, e1, tcd->vthis);
- e1->type = tcd->vthis->type;
- e1->type = e1->type->addMod(t->mod);
- // Do not call checkNestedRef()
- //e1 = expressionSemantic(e1, sc);
-
- // Skip up over nested functions, and get the enclosing
- // class type.
- int n = 0;
- Dsymbol *s;
- for (s = tcd->toParent();
- s && s->isFuncDeclaration();
- s = s->toParent())
- {
- FuncDeclaration *f = s->isFuncDeclaration();
- if (f->vthis)
- {
- //printf("rewriting e1 to %s's this\n", f->toChars());
- n++;
- e1 = new VarExp(loc, f->vthis);
- }
- else
- {
- e1->error("need `this` of type %s to access member %s"
- " from static function %s",
- ad->toChars(), var->toChars(), f->toChars());
- e1 = new ErrorExp();
- return e1;
- }
- }
- if (s && s->isClassDeclaration())
- {
- e1->type = s->isClassDeclaration()->type;
- e1->type = e1->type->addMod(t->mod);
- if (n > 1)
- e1 = expressionSemantic(e1, sc);
- }
- else
- e1 = expressionSemantic(e1, sc);
- goto L1;
- }
-
- /* Can't find a path from e1 to ad
- */
- if (flag)
- return NULL;
- e1->error("this for %s needs to be type %s not type %s",
- var->toChars(), ad->toChars(), t->toChars());
- return new ErrorExp();
- }
- }
- return e1;
-}
+void toAutoQualChars(const char **result, Type *t1, Type *t2);
/*****************************************
* Determine if 'this' is available.
@@ -230,817 +130,112 @@ bool isNeedThisScope(Scope *sc, Declaration *d)
return true;
}
-/***************************************
- * Pull out any properties.
+/******************************
+ * check e is exp.opDispatch!(tiargs) or not
+ * It's used to switch to UFCS the semantic analysis path
*/
-Expression *resolvePropertiesX(Scope *sc, Expression *e1, Expression *e2 = NULL)
+bool isDotOpDispatch(Expression *e)
{
- //printf("resolvePropertiesX, e1 = %s %s, e2 = %s\n", Token::toChars(e1->op), e1->toChars(), e2 ? e2->toChars() : NULL);
- Loc loc = e1->loc;
-
- OverloadSet *os;
- Dsymbol *s;
- Objects *tiargs;
- Type *tthis;
- if (e1->op == TOKdot)
- {
- DotExp *de = (DotExp *)e1;
- if (de->e2->op == TOKoverloadset)
- {
- tiargs = NULL;
- tthis = de->e1->type;
- os = ((OverExp *)de->e2)->vars;
- goto Los;
- }
- }
- else if (e1->op == TOKoverloadset)
- {
- tiargs = NULL;
- tthis = NULL;
- os = ((OverExp *)e1)->vars;
- Los:
- assert(os);
- FuncDeclaration *fd = NULL;
- if (e2)
- {
- e2 = expressionSemantic(e2, sc);
- if (e2->op == TOKerror)
- return new ErrorExp();
- e2 = resolveProperties(sc, e2);
+ return e->op == TOKdotti &&
+ ((DotTemplateInstanceExp *)e)->ti->name == Id::opDispatch;
+}
- Expressions a;
- a.push(e2);
+/****************************************
+ * Expand tuples.
+ * Input:
+ * exps aray of Expressions
+ * Output:
+ * exps rewritten in place
+ */
- for (size_t i = 0; i < os->a.length; i++)
- {
- FuncDeclaration *f = resolveFuncCall(loc, sc, os->a[i], tiargs, tthis, &a, 1);
- if (f)
- {
- if (f->errors)
- return new ErrorExp();
- fd = f;
- assert(fd->type->ty == Tfunction);
- }
- }
- if (fd)
- {
- Expression *e = new CallExp(loc, e1, e2);
- return expressionSemantic(e, sc);
- }
- }
- {
- for (size_t i = 0; i < os->a.length; i++)
- {
- FuncDeclaration *f = resolveFuncCall(loc, sc, os->a[i], tiargs, tthis, NULL, 1);
- if (f)
- {
- if (f->errors)
- return new ErrorExp();
- fd = f;
- assert(fd->type->ty == Tfunction);
- TypeFunction *tf = (TypeFunction *)fd->type;
- if (!tf->isref && e2)
- goto Leproplvalue;
- }
- }
- if (fd)
- {
- Expression *e = new CallExp(loc, e1);
- if (e2)
- e = new AssignExp(loc, e, e2);
- return expressionSemantic(e, sc);
- }
- }
- if (e2)
- goto Leprop;
- }
- else if (e1->op == TOKdotti)
- {
- DotTemplateInstanceExp* dti = (DotTemplateInstanceExp *)e1;
- if (!dti->findTempDecl(sc))
- goto Leprop;
- if (!dti->ti->semanticTiargs(sc))
- goto Leprop;
- tiargs = dti->ti->tiargs;
- tthis = dti->e1->type;
- if ((os = dti->ti->tempdecl->isOverloadSet()) != NULL)
- goto Los;
- if ((s = dti->ti->tempdecl) != NULL)
- goto Lfd;
- }
- else if (e1->op == TOKdottd)
- {
- DotTemplateExp *dte = (DotTemplateExp *)e1;
- s = dte->td;
- tiargs = NULL;
- tthis = dte->e1->type;
- goto Lfd;
- }
- else if (e1->op == TOKscope)
- {
- s = ((ScopeExp *)e1)->sds;
- TemplateInstance *ti = s->isTemplateInstance();
- if (ti && !ti->semanticRun && ti->tempdecl)
- {
- //assert(ti->needsTypeInference(sc));
- if (!ti->semanticTiargs(sc))
- goto Leprop;
- tiargs = ti->tiargs;
- tthis = NULL;
- if ((os = ti->tempdecl->isOverloadSet()) != NULL)
- goto Los;
- if ((s = ti->tempdecl) != NULL)
- goto Lfd;
- }
- }
- else if (e1->op == TOKtemplate)
- {
- s = ((TemplateExp *)e1)->td;
- tiargs = NULL;
- tthis = NULL;
- goto Lfd;
- }
- else if (e1->op == TOKdotvar && e1->type && e1->type->toBasetype()->ty == Tfunction)
- {
- DotVarExp *dve = (DotVarExp *)e1;
- s = dve->var->isFuncDeclaration();
- tiargs = NULL;
- tthis = dve->e1->type;
- goto Lfd;
- }
- else if (e1->op == TOKvar && e1->type && e1->type->toBasetype()->ty == Tfunction)
+void expandTuples(Expressions *exps)
+{
+ //printf("expandTuples()\n");
+ if (exps)
{
- s = ((VarExp *)e1)->var->isFuncDeclaration();
- tiargs = NULL;
- tthis = NULL;
- Lfd:
- assert(s);
- if (e2)
+ for (size_t i = 0; i < exps->length; i++)
{
- e2 = expressionSemantic(e2, sc);
- if (e2->op == TOKerror)
- return new ErrorExp();
- e2 = resolveProperties(sc, e2);
-
- Expressions a;
- a.push(e2);
+ Expression *arg = (*exps)[i];
+ if (!arg)
+ continue;
- FuncDeclaration *fd = resolveFuncCall(loc, sc, s, tiargs, tthis, &a, 1);
- if (fd && fd->type)
- {
- if (fd->errors)
- return new ErrorExp();
- assert(fd->type->ty == Tfunction);
- Expression *e = new CallExp(loc, e1, e2);
- return expressionSemantic(e, sc);
- }
- }
- {
- FuncDeclaration *fd = resolveFuncCall(loc, sc, s, tiargs, tthis, NULL, 1);
- if (fd && fd->type)
+ // Look for tuple with 0 members
+ if (arg->op == TOKtype)
{
- if (fd->errors)
- return new ErrorExp();
- assert(fd->type->ty == Tfunction);
- TypeFunction *tf = (TypeFunction *)fd->type;
- if (!e2 || tf->isref)
+ TypeExp *e = (TypeExp *)arg;
+ if (e->type->toBasetype()->ty == Ttuple)
{
- Expression *e = new CallExp(loc, e1);
- if (e2)
- e = new AssignExp(loc, e, e2);
- return expressionSemantic(e, sc);
- }
- }
- }
- if (FuncDeclaration *fd = s->isFuncDeclaration())
- {
- // Keep better diagnostic message for invalid property usage of functions
- assert(fd->type->ty == Tfunction);
- Expression *e = new CallExp(loc, e1, e2);
- return expressionSemantic(e, sc);
- }
- if (e2)
- goto Leprop;
- }
- if (e1->op == TOKvar)
- {
- VarExp *ve = (VarExp *)e1;
- VarDeclaration *v = ve->var->isVarDeclaration();
- if (v && ve->checkPurity(sc, v))
- return new ErrorExp();
- }
- if (e2)
- return NULL;
-
- if (e1->type &&
- e1->op != TOKtype) // function type is not a property
- {
- /* Look for e1 being a lazy parameter; rewrite as delegate call
- */
- if (e1->op == TOKvar)
- {
- VarExp *ve = (VarExp *)e1;
+ TypeTuple *tt = (TypeTuple *)e->type->toBasetype();
- if (ve->var->storage_class & STClazy)
- {
- Expression *e = new CallExp(loc, e1);
- return expressionSemantic(e, sc);
+ if (!tt->arguments || tt->arguments->length == 0)
+ {
+ exps->remove(i);
+ if (i == exps->length)
+ return;
+ i--;
+ continue;
+ }
+ }
}
- }
- else if (e1->op == TOKdotvar)
- {
- // Check for reading overlapped pointer field in @safe code.
- if (checkUnsafeAccess(sc, e1, true, true))
- return new ErrorExp();
- }
- else if (e1->op == TOKdot)
- {
- e1->error("expression has no value");
- return new ErrorExp();
- }
- else if (e1->op == TOKcall)
- {
- CallExp *ce = (CallExp *)e1;
- // Check for reading overlapped pointer field in @safe code.
- if (checkUnsafeAccess(sc, ce->e1, true, true))
- return new ErrorExp();
- }
- }
-
- if (!e1->type)
- {
- error(loc, "cannot resolve type for %s", e1->toChars());
- e1 = new ErrorExp();
- }
- return e1;
-
-Leprop:
- error(loc, "not a property %s", e1->toChars());
- return new ErrorExp();
-
-Leproplvalue:
- error(loc, "%s is not an lvalue", e1->toChars());
- return new ErrorExp();
-}
-
-Expression *resolveProperties(Scope *sc, Expression *e)
-{
- //printf("resolveProperties(%s)\n", e->toChars());
-
- e = resolvePropertiesX(sc, e);
- if (e->checkRightThis(sc))
- return new ErrorExp();
- return e;
-}
-
-/******************************
- * Check the tail CallExp is really property function call.
- */
-static bool checkPropertyCall(Expression *e)
-{
- while (e->op == TOKcomma)
- e = ((CommaExp *)e)->e2;
- if (e->op == TOKcall)
- {
- CallExp *ce = (CallExp *)e;
- TypeFunction *tf;
- if (ce->f)
- {
- tf = (TypeFunction *)ce->f->type;
- /* If a forward reference to ce->f, try to resolve it
- */
- if (!tf->deco && ce->f->semanticRun < PASSsemanticdone)
+ // Inline expand all the tuples
+ while (arg->op == TOKtuple)
{
- dsymbolSemantic(ce->f, NULL);
- tf = (TypeFunction *)ce->f->type;
+ TupleExp *te = (TupleExp *)arg;
+ exps->remove(i); // remove arg
+ exps->insert(i, te->exps); // replace with tuple contents
+ if (i == exps->length)
+ return; // empty tuple, no more arguments
+ (*exps)[i] = Expression::combine(te->e0, (*exps)[i]);
+ arg = (*exps)[i];
}
}
- else if (ce->e1->type->ty == Tfunction)
- tf = (TypeFunction *)ce->e1->type;
- else if (ce->e1->type->ty == Tdelegate)
- tf = (TypeFunction *)ce->e1->type->nextOf();
- else if (ce->e1->type->ty == Tpointer && ce->e1->type->nextOf()->ty == Tfunction)
- tf = (TypeFunction *)ce->e1->type->nextOf();
- else
- assert(0);
}
- return false;
}
-/******************************
- * If e1 is a property function (template), resolve it.
+/****************************************
+ * Expand alias this tuples.
*/
-Expression *resolvePropertiesOnly(Scope *sc, Expression *e1)
+TupleDeclaration *isAliasThisTuple(Expression *e)
{
- //printf("e1 = %s %s\n", Token::toChars(e1->op), e1->toChars());
- OverloadSet *os;
- FuncDeclaration *fd;
- TemplateDeclaration *td;
+ if (!e->type)
+ return NULL;
- if (e1->op == TOKdot)
- {
- DotExp *de = (DotExp *)e1;
- if (de->e2->op == TOKoverloadset)
- {
- os = ((OverExp *)de->e2)->vars;
- goto Los;
- }
- }
- else if (e1->op == TOKoverloadset)
- {
- os = ((OverExp *)e1)->vars;
- Los:
- assert(os);
- for (size_t i = 0; i < os->a.length; i++)
- {
- Dsymbol *s = os->a[i];
- fd = s->isFuncDeclaration();
- td = s->isTemplateDeclaration();
- if (fd)
- {
- if (((TypeFunction *)fd->type)->isproperty)
- return resolveProperties(sc, e1);
- }
- else if (td && td->onemember &&
- (fd = td->onemember->isFuncDeclaration()) != NULL)
- {
- if (((TypeFunction *)fd->type)->isproperty ||
- (fd->storage_class2 & STCproperty) ||
- (td->_scope->stc & STCproperty))
- {
- return resolveProperties(sc, e1);
- }
- }
- }
- }
- else if (e1->op == TOKdotti)
- {
- DotTemplateInstanceExp* dti = (DotTemplateInstanceExp *)e1;
- if (dti->ti->tempdecl && (td = dti->ti->tempdecl->isTemplateDeclaration()) != NULL)
- goto Ltd;
- }
- else if (e1->op == TOKdottd)
- {
- td = ((DotTemplateExp *)e1)->td;
- goto Ltd;
- }
- else if (e1->op == TOKscope)
- {
- Dsymbol *s = ((ScopeExp *)e1)->sds;
- TemplateInstance *ti = s->isTemplateInstance();
- if (ti && !ti->semanticRun && ti->tempdecl)
- {
- if ((td = ti->tempdecl->isTemplateDeclaration()) != NULL)
- goto Ltd;
- }
- }
- else if (e1->op == TOKtemplate)
+ Type *t = e->type->toBasetype();
+Lagain:
+ if (Dsymbol *s = t->toDsymbol(NULL))
{
- td = ((TemplateExp *)e1)->td;
- Ltd:
- assert(td);
- if (td->onemember &&
- (fd = td->onemember->isFuncDeclaration()) != NULL)
+ AggregateDeclaration *ad = s->isAggregateDeclaration();
+ if (ad)
{
- if (((TypeFunction *)fd->type)->isproperty ||
- (fd->storage_class2 & STCproperty) ||
- (td->_scope->stc & STCproperty))
+ s = ad->aliasthis;
+ if (s && s->isVarDeclaration())
{
- return resolveProperties(sc, e1);
+ TupleDeclaration *td = s->isVarDeclaration()->toAlias()->isTupleDeclaration();
+ if (td && td->isexp)
+ return td;
}
- }
- }
- else if (e1->op == TOKdotvar && e1->type->ty == Tfunction)
- {
- DotVarExp *dve = (DotVarExp *)e1;
- fd = dve->var->isFuncDeclaration();
- goto Lfd;
- }
- else if (e1->op == TOKvar && e1->type->ty == Tfunction &&
- (sc->intypeof || !((VarExp *)e1)->var->needThis()))
- {
- fd = ((VarExp *)e1)->var->isFuncDeclaration();
- Lfd:
- assert(fd);
- if (((TypeFunction *)fd->type)->isproperty)
- return resolveProperties(sc, e1);
- }
- return e1;
-}
-
-
-// TODO: merge with Scope::search::searchScopes()
-static Dsymbol *searchScopes(Scope *sc, Loc loc, Identifier *ident, int flags)
-{
- Dsymbol *s = NULL;
- for (Scope *scx = sc; scx; scx = scx->enclosing)
- {
- if (!scx->scopesym)
- continue;
- if (scx->scopesym->isModule())
- flags |= SearchUnqualifiedModule; // tell Module.search() that SearchLocalsOnly is to be obeyed
- s = scx->scopesym->search(loc, ident, flags);
- if (s)
- {
- // overload set contains only module scope symbols.
- if (s->isOverloadSet())
- break;
- // selective/renamed imports also be picked up
- if (AliasDeclaration *ad = s->isAliasDeclaration())
+ if (Type *att = t->aliasthisOf())
{
- if (ad->_import)
- break;
+ t = att;
+ goto Lagain;
}
- // See only module scope symbols for UFCS target.
- Dsymbol *p = s->toParent2();
- if (p && p->isModule())
- break;
}
- s = NULL;
-
- // Stop when we hit a module, but keep going if that is not just under the global scope
- if (scx->scopesym->isModule() && !(scx->enclosing && !scx->enclosing->enclosing))
- break;
}
- return s;
+ return NULL;
}
-/******************************
- * Find symbol in accordance with the UFCS name look up rule
- */
-
-static Expression *searchUFCS(Scope *sc, UnaExp *ue, Identifier *ident)
+int expandAliasThisTuples(Expressions *exps, size_t starti)
{
- //printf("searchUFCS(ident = %s)\n", ident->toChars());
- Loc loc = ue->loc;
- int flags = 0;
- Dsymbol *s = NULL;
-
- if (sc->flags & SCOPEignoresymbolvisibility)
- flags |= IgnoreSymbolVisibility;
-
- // First look in local scopes
- s = searchScopes(sc, loc, ident, flags | SearchLocalsOnly);
- if (!s)
- {
- // Second look in imported modules
- s = searchScopes(sc, loc, ident, flags | SearchImportsOnly);
- }
-
- if (!s)
- return ue->e1->type->Type::getProperty(loc, ident, 0);
+ if (!exps || exps->length == 0)
+ return -1;
- FuncDeclaration *f = s->isFuncDeclaration();
- if (f)
+ for (size_t u = starti; u < exps->length; u++)
{
- TemplateDeclaration *td = getFuncTemplateDecl(f);
- if (td)
- {
- if (td->overroot)
- td = td->overroot;
- s = td;
- }
- }
-
- if (ue->op == TOKdotti)
- {
- DotTemplateInstanceExp *dti = (DotTemplateInstanceExp *)ue;
- TemplateInstance *ti = new TemplateInstance(loc, s->ident);
- ti->tiargs = dti->ti->tiargs; // for better diagnostic message
- if (!ti->updateTempDecl(sc, s))
- return new ErrorExp();
- return new ScopeExp(loc, ti);
- }
- else
- {
- //printf("-searchUFCS() %s\n", s->toChars());
- return new DsymbolExp(loc, s);
- }
-}
-
-/******************************
- * check e is exp.opDispatch!(tiargs) or not
- * It's used to switch to UFCS the semantic analysis path
- */
-
-bool isDotOpDispatch(Expression *e)
-{
- return e->op == TOKdotti &&
- ((DotTemplateInstanceExp *)e)->ti->name == Id::opDispatch;
-}
-
-/******************************
- * Pull out callable entity with UFCS.
- */
-
-Expression *resolveUFCS(Scope *sc, CallExp *ce)
-{
- Loc loc = ce->loc;
- Expression *eleft;
- Expression *e;
-
- if (ce->e1->op == TOKdotid)
- {
- DotIdExp *die = (DotIdExp *)ce->e1;
- Identifier *ident = die->ident;
-
- Expression *ex = semanticX(die, sc);
- if (ex != die)
- {
- ce->e1 = ex;
- return NULL;
- }
- eleft = die->e1;
-
- Type *t = eleft->type->toBasetype();
- if (t->ty == Tarray || t->ty == Tsarray ||
- t->ty == Tnull || (t->isTypeBasic() && t->ty != Tvoid))
- {
- /* Built-in types and arrays have no callable properties, so do shortcut.
- * It is necessary in: e.init()
- */
- }
- else if (t->ty == Taarray)
- {
- if (ident == Id::remove)
- {
- /* Transform:
- * aa.remove(arg) into delete aa[arg]
- */
- if (!ce->arguments || ce->arguments->length != 1)
- {
- ce->error("expected key as argument to aa.remove()");
- return new ErrorExp();
- }
- if (!eleft->type->isMutable())
- {
- ce->error("cannot remove key from %s associative array %s",
- MODtoChars(t->mod), eleft->toChars());
- return new ErrorExp();
- }
- Expression *key = (*ce->arguments)[0];
- key = expressionSemantic(key, sc);
- key = resolveProperties(sc, key);
-
- TypeAArray *taa = (TypeAArray *)t;
- key = key->implicitCastTo(sc, taa->index);
-
- if (key->checkValue())
- return new ErrorExp();
-
- semanticTypeInfo(sc, taa->index);
-
- return new RemoveExp(loc, eleft, key);
- }
- }
- else
- {
- if (Expression *ey = semanticY(die, sc, 1))
- {
- if (ey->op == TOKerror)
- return ey;
- ce->e1 = ey;
- if (isDotOpDispatch(ey))
- {
- unsigned errors = global.startGagging();
- e = expressionSemantic(ce->syntaxCopy(), sc);
- if (!global.endGagging(errors))
- return e;
- /* fall down to UFCS */
- }
- else
- return NULL;
- }
- }
- e = searchUFCS(sc, die, ident);
- }
- else if (ce->e1->op == TOKdotti)
- {
- DotTemplateInstanceExp *dti = (DotTemplateInstanceExp *)ce->e1;
- if (Expression *ey = semanticY(dti, sc, 1))
- {
- ce->e1 = ey;
- return NULL;
- }
- eleft = dti->e1;
- e = searchUFCS(sc, dti, dti->ti->name);
- }
- else
- return NULL;
-
- // Rewrite
- ce->e1 = e;
- if (!ce->arguments)
- ce->arguments = new Expressions();
- ce->arguments->shift(eleft);
-
- return NULL;
-}
-
-/******************************
- * Pull out property with UFCS.
- */
-
-Expression *resolveUFCSProperties(Scope *sc, Expression *e1, Expression *e2 = NULL)
-{
- Loc loc = e1->loc;
- Expression *eleft;
- Expression *e;
-
- if (e1->op == TOKdotid)
- {
- DotIdExp *die = (DotIdExp *)e1;
- eleft = die->e1;
- e = searchUFCS(sc, die, die->ident);
- }
- else if (e1->op == TOKdotti)
- {
- DotTemplateInstanceExp *dti;
- dti = (DotTemplateInstanceExp *)e1;
- eleft = dti->e1;
- e = searchUFCS(sc, dti, dti->ti->name);
- }
- else
- return NULL;
-
- if (e == NULL)
- return NULL;
-
- // Rewrite
- if (e2)
- {
- // run semantic without gagging
- e2 = expressionSemantic(e2, sc);
-
- /* f(e1) = e2
- */
- Expression *ex = e->copy();
- Expressions *a1 = new Expressions();
- a1->setDim(1);
- (*a1)[0] = eleft;
- ex = new CallExp(loc, ex, a1);
- ex = trySemantic(ex, sc);
-
- /* f(e1, e2)
- */
- Expressions *a2 = new Expressions();
- a2->setDim(2);
- (*a2)[0] = eleft;
- (*a2)[1] = e2;
- e = new CallExp(loc, e, a2);
- if (ex)
- { // if fallback setter exists, gag errors
- e = trySemantic(e, sc);
- if (!e)
- { checkPropertyCall(ex);
- ex = new AssignExp(loc, ex, e2);
- return expressionSemantic(ex, sc);
- }
- }
- else
- { // strict setter prints errors if fails
- e = expressionSemantic(e, sc);
- }
- checkPropertyCall(e);
- return e;
- }
- else
- {
- /* f(e1)
- */
- Expressions *arguments = new Expressions();
- arguments->setDim(1);
- (*arguments)[0] = eleft;
- e = new CallExp(loc, e, arguments);
- e = expressionSemantic(e, sc);
- checkPropertyCall(e);
- return expressionSemantic(e, sc);
- }
-}
-
-/******************************
- * Perform semantic() on an array of Expressions.
- */
-
-bool arrayExpressionSemantic(Expressions *exps, Scope *sc, bool preserveErrors)
-{
- bool err = false;
- if (exps)
- {
- for (size_t i = 0; i < exps->length; i++)
- {
- Expression *e = (*exps)[i];
- if (e)
- {
- e = expressionSemantic(e, sc);
- if (e->op == TOKerror)
- err = true;
- if (preserveErrors || e->op != TOKerror)
- (*exps)[i] = e;
- }
- }
- }
- return err;
-}
-
-/****************************************
- * Expand tuples.
- * Input:
- * exps aray of Expressions
- * Output:
- * exps rewritten in place
- */
-
-void expandTuples(Expressions *exps)
-{
- //printf("expandTuples()\n");
- if (exps)
- {
- for (size_t i = 0; i < exps->length; i++)
- {
- Expression *arg = (*exps)[i];
- if (!arg)
- continue;
-
- // Look for tuple with 0 members
- if (arg->op == TOKtype)
- {
- TypeExp *e = (TypeExp *)arg;
- if (e->type->toBasetype()->ty == Ttuple)
- {
- TypeTuple *tt = (TypeTuple *)e->type->toBasetype();
-
- if (!tt->arguments || tt->arguments->length == 0)
- {
- exps->remove(i);
- if (i == exps->length)
- return;
- i--;
- continue;
- }
- }
- }
-
- // Inline expand all the tuples
- while (arg->op == TOKtuple)
- {
- TupleExp *te = (TupleExp *)arg;
- exps->remove(i); // remove arg
- exps->insert(i, te->exps); // replace with tuple contents
- if (i == exps->length)
- return; // empty tuple, no more arguments
- (*exps)[i] = Expression::combine(te->e0, (*exps)[i]);
- arg = (*exps)[i];
- }
- }
- }
-}
-
-/****************************************
- * Expand alias this tuples.
- */
-
-TupleDeclaration *isAliasThisTuple(Expression *e)
-{
- if (!e->type)
- return NULL;
-
- Type *t = e->type->toBasetype();
-Lagain:
- if (Dsymbol *s = t->toDsymbol(NULL))
- {
- AggregateDeclaration *ad = s->isAggregateDeclaration();
- if (ad)
- {
- s = ad->aliasthis;
- if (s && s->isVarDeclaration())
- {
- TupleDeclaration *td = s->isVarDeclaration()->toAlias()->isTupleDeclaration();
- if (td && td->isexp)
- return td;
- }
- if (Type *att = t->aliasthisOf())
- {
- t = att;
- goto Lagain;
- }
- }
- }
- return NULL;
-}
-
-int expandAliasThisTuples(Expressions *exps, size_t starti)
-{
- if (!exps || exps->length == 0)
- return -1;
-
- for (size_t u = starti; u < exps->length; u++)
- {
- Expression *exp = (*exps)[u];
- TupleDeclaration *td = isAliasThisTuple(exp);
+ Expression *exp = (*exps)[u];
+ TupleDeclaration *td = isAliasThisTuple(exp);
if (td)
{
exps->remove(u);
@@ -1061,907 +256,130 @@ int expandAliasThisTuples(Expressions *exps, size_t starti)
}
}
- return -1;
-}
-
-/****************************************
- * The common type is determined by applying ?: to each pair.
- * Output:
- * exps[] properties resolved, implicitly cast to common type, rewritten in place
- * *pt if pt is not NULL, set to the common type
- * Returns:
- * true a semantic error was detected
- */
-
-bool arrayExpressionToCommonType(Scope *sc, Expressions *exps, Type **pt)
-{
- /* Still have a problem with:
- * ubyte[][] = [ cast(ubyte[])"hello", [1]];
- * which works if the array literal is initialized top down with the ubyte[][]
- * type, but fails with this function doing bottom up typing.
- */
- //printf("arrayExpressionToCommonType()\n");
- IntegerExp integerexp(0);
- CondExp condexp(Loc(), &integerexp, NULL, NULL);
-
- Type *t0 = NULL;
- Expression *e0 = NULL; // dead-store to prevent spurious warning
- size_t j0 = ~0; // dead-store to prevent spurious warning
- bool foundType = false;
-
- for (size_t i = 0; i < exps->length; i++)
- {
- Expression *e = (*exps)[i];
- if (!e)
- continue;
-
- e = resolveProperties(sc, e);
- if (!e->type)
- {
- e->error("%s has no value", e->toChars());
- t0 = Type::terror;
- continue;
- }
- if (e->op == TOKtype)
- {
- foundType = true; // do not break immediately, there might be more errors
- e->checkValue(); // report an error "type T has no value"
- t0 = Type::terror;
- continue;
- }
- if (e->type->ty == Tvoid)
- {
- // void expressions do not concur to the determination of the common
- // type.
- continue;
- }
- if (checkNonAssignmentArrayOp(e))
- {
- t0 = Type::terror;
- continue;
- }
-
- e = doCopyOrMove(sc, e);
-
- if (!foundType && t0 && !t0->equals(e->type))
- {
- /* This applies ?: to merge the types. It's backwards;
- * ?: should call this function to merge types.
- */
- condexp.type = NULL;
- condexp.e1 = e0;
- condexp.e2 = e;
- condexp.loc = e->loc;
- Expression *ex = expressionSemantic(&condexp, sc);
- if (ex->op == TOKerror)
- e = ex;
- else
- {
- (*exps)[j0] = condexp.e1;
- e = condexp.e2;
- }
- }
- j0 = i;
- e0 = e;
- t0 = e->type;
- if (e->op != TOKerror)
- (*exps)[i] = e;
- }
-
- if (!t0)
- t0 = Type::tvoid; // [] is typed as void[]
- else if (t0->ty != Terror)
- {
- for (size_t i = 0; i < exps->length; i++)
- {
- Expression *e = (*exps)[i];
- if (!e)
- continue;
-
- e = e->implicitCastTo(sc, t0);
- //assert(e->op != TOKerror);
- if (e->op == TOKerror)
- {
- /* Bugzilla 13024: a workaround for the bug in typeMerge -
- * it should paint e1 and e2 by deduced common type,
- * but doesn't in this particular case.
- */
- t0 = Type::terror;
- break;
- }
- (*exps)[i] = e;
- }
- }
- if (pt)
- *pt = t0;
-
- return (t0 == Type::terror);
-}
-
-/****************************************
- * Get TemplateDeclaration enclosing FuncDeclaration.
- */
-
-TemplateDeclaration *getFuncTemplateDecl(Dsymbol *s)
-{
- FuncDeclaration *f = s->isFuncDeclaration();
- if (f && f->parent)
- {
- TemplateInstance *ti = f->parent->isTemplateInstance();
- if (ti && !ti->isTemplateMixin() &&
- ti->tempdecl && ((TemplateDeclaration *)ti->tempdecl)->onemember &&
- ti->tempdecl->ident == f->ident)
- {
- return (TemplateDeclaration *)ti->tempdecl;
- }
- }
- return NULL;
-}
-
-/************************************************
- * If we want the value of this expression, but do not want to call
- * the destructor on it.
- */
-
-Expression *valueNoDtor(Expression *e)
-{
- if (e->op == TOKcall)
- {
- /* The struct value returned from the function is transferred
- * so do not call the destructor on it.
- * Recognize:
- * ((S _ctmp = S.init), _ctmp).this(...)
- * and make sure the destructor is not called on _ctmp
- * BUG: if e is a CommaExp, we should go down the right side.
- */
- CallExp *ce = (CallExp *)e;
- if (ce->e1->op == TOKdotvar)
- {
- DotVarExp *dve = (DotVarExp *)ce->e1;
- if (dve->var->isCtorDeclaration())
- {
- // It's a constructor call
- if (dve->e1->op == TOKcomma)
- {
- CommaExp *comma = (CommaExp *)dve->e1;
- if (comma->e2->op == TOKvar)
- {
- VarExp *ve = (VarExp *)comma->e2;
- VarDeclaration *ctmp = ve->var->isVarDeclaration();
- if (ctmp)
- {
- ctmp->storage_class |= STCnodtor;
- assert(!ce->isLvalue());
- }
- }
- }
- }
- }
- }
- else if (e->op == TOKvar)
- {
- VarDeclaration *vtmp = ((VarExp *)e)->var->isVarDeclaration();
- if (vtmp && vtmp->storage_class & STCrvalue)
- {
- vtmp->storage_class |= STCnodtor;
- }
- }
- return e;
-}
-
-/********************************************
- * Issue an error if default construction is disabled for type t.
- * Default construction is required for arrays and 'out' parameters.
- * Returns:
- * true an error was issued
- */
-bool checkDefCtor(Loc loc, Type *t)
-{
- t = t->baseElemOf();
- if (t->ty == Tstruct)
- {
- StructDeclaration *sd = ((TypeStruct *)t)->sym;
- if (sd->noDefaultCtor)
- {
- sd->error(loc, "default construction is disabled");
- return true;
- }
- }
- return false;
-}
-
-/*********************************************
- * If e is an instance of a struct, and that struct has a copy constructor,
- * rewrite e as:
- * (tmp = e),tmp
- * Input:
- * sc just used to specify the scope of created temporary variable
- */
-Expression *callCpCtor(Scope *sc, Expression *e)
-{
- Type *tv = e->type->baseElemOf();
- if (tv->ty == Tstruct)
- {
- StructDeclaration *sd = ((TypeStruct *)tv)->sym;
- if (sd->postblit)
- {
- /* Create a variable tmp, and replace the argument e with:
- * (tmp = e),tmp
- * and let AssignExp() handle the construction.
- * This is not the most efficent, ideally tmp would be constructed
- * directly onto the stack.
- */
- VarDeclaration *tmp = copyToTemp(STCrvalue, "__copytmp", e);
- tmp->storage_class |= STCnodtor;
- dsymbolSemantic(tmp, sc);
- Expression *de = new DeclarationExp(e->loc, tmp);
- Expression *ve = new VarExp(e->loc, tmp);
- de->type = Type::tvoid;
- ve->type = e->type;
- e = Expression::combine(de, ve);
- }
- }
- return e;
-}
-
-/************************************************
- * Handle the postblit call on lvalue, or the move of rvalue.
- */
-Expression *doCopyOrMove(Scope *sc, Expression *e)
-{
- if (e->op == TOKquestion)
- {
- CondExp *ce = (CondExp *)e;
- ce->e1 = doCopyOrMove(sc, ce->e1);
- ce->e2 = doCopyOrMove(sc, ce->e2);
- }
- else
- {
- e = e->isLvalue() ? callCpCtor(sc, e) : valueNoDtor(e);
- }
- return e;
-}
-
-/****************************************
- * Now that we know the exact type of the function we're calling,
- * the arguments[] need to be adjusted:
- * 1. implicitly convert argument to the corresponding parameter type
- * 2. add default arguments for any missing arguments
- * 3. do default promotions on arguments corresponding to ...
- * 4. add hidden _arguments[] argument
- * 5. call copy constructor for struct value arguments
- * Input:
- * tf type of the function
- * fd the function being called, NULL if called indirectly
- * Output:
- * *prettype return type of function
- * *peprefix expression to execute before arguments[] are evaluated, NULL if none
- * Returns:
- * true errors happened
- */
-
-bool functionParameters(Loc loc, Scope *sc, TypeFunction *tf,
- Type *tthis, Expressions *arguments, FuncDeclaration *fd, Type **prettype, Expression **peprefix)
-{
- //printf("functionParameters()\n");
- assert(arguments);
- assert(fd || tf->next);
- size_t nargs = arguments ? arguments->length : 0;
- size_t nparams = tf->parameterList.length();
- unsigned olderrors = global.errors;
- bool err = false;
- *prettype = Type::terror;
- Expression *eprefix = NULL;
- *peprefix = NULL;
-
- if (nargs > nparams && tf->parameterList.varargs == VARARGnone)
- {
- error(loc, "expected %llu arguments, not %llu for non-variadic function type %s", (ulonglong)nparams, (ulonglong)nargs, tf->toChars());
- return true;
- }
-
- // If inferring return type, and semantic3() needs to be run if not already run
- if (!tf->next && fd->inferRetType)
- {
- fd->functionSemantic();
- }
- else if (fd && fd->parent)
- {
- TemplateInstance *ti = fd->parent->isTemplateInstance();
- if (ti && ti->tempdecl)
- {
- fd->functionSemantic3();
- }
- }
- bool isCtorCall = fd && fd->needThis() && fd->isCtorDeclaration();
-
- size_t n = (nargs > nparams) ? nargs : nparams; // n = max(nargs, nparams)
-
- /* If the function return type has wildcards in it, we'll need to figure out the actual type
- * based on the actual argument types.
- */
- MOD wildmatch = 0;
- if (tthis && tf->isWild() && !isCtorCall)
- {
- Type *t = tthis;
- if (t->isImmutable())
- wildmatch = MODimmutable;
- else if (t->isWildConst())
- wildmatch = MODwildconst;
- else if (t->isWild())
- wildmatch = MODwild;
- else if (t->isConst())
- wildmatch = MODconst;
- else
- wildmatch = MODmutable;
- }
-
- int done = 0;
- for (size_t i = 0; i < n; i++)
- {
- Expression *arg;
-
- if (i < nargs)
- arg = (*arguments)[i];
- else
- arg = NULL;
-
- if (i < nparams)
- {
- Parameter *p = tf->parameterList[i];
-
- if (!arg)
- {
- if (!p->defaultArg)
- {
- if (tf->parameterList.varargs == VARARGtypesafe && i + 1 == nparams)
- goto L2;
- error(loc, "expected %llu function arguments, not %llu", (ulonglong)nparams, (ulonglong)nargs);
- return true;
- }
- arg = p->defaultArg;
- arg = inlineCopy(arg, sc);
- // __FILE__, __LINE__, __MODULE__, __FUNCTION__, and __PRETTY_FUNCTION__
- arg = arg->resolveLoc(loc, sc);
- arguments->push(arg);
- nargs++;
- }
-
- if (tf->parameterList.varargs == VARARGtypesafe && i + 1 == nparams)
- {
- //printf("\t\tvarargs == 2, p->type = '%s'\n", p->type->toChars());
- {
- MATCH m;
- if ((m = arg->implicitConvTo(p->type)) > MATCHnomatch)
- {
- if (p->type->nextOf() && arg->implicitConvTo(p->type->nextOf()) >= m)
- goto L2;
- else if (nargs != nparams)
- { error(loc, "expected %llu function arguments, not %llu", (ulonglong)nparams, (ulonglong)nargs);
- return true;
- }
- goto L1;
- }
- }
- L2:
- Type *tb = p->type->toBasetype();
- Type *tret = p->isLazyArray();
- switch (tb->ty)
- {
- case Tsarray:
- case Tarray:
- {
- /* Create a static array variable v of type arg->type:
- * T[dim] __arrayArg = [ arguments[i], ..., arguments[nargs-1] ];
- *
- * The array literal in the initializer of the hidden variable
- * is now optimized. See Bugzilla 2356.
- */
- Type *tbn = ((TypeArray *)tb)->next;
-
- Expressions *elements = new Expressions();
- elements->setDim(nargs - i);
- for (size_t u = 0; u < elements->length; u++)
- {
- Expression *a = (*arguments)[i + u];
- if (tret && a->implicitConvTo(tret))
- {
- a = a->implicitCastTo(sc, tret);
- a = a->optimize(WANTvalue);
- a = toDelegate(a, a->type, sc);
- }
- else
- a = a->implicitCastTo(sc, tbn);
- (*elements)[u] = a;
- }
- // Bugzilla 14395: Convert to a static array literal, or its slice.
- arg = new ArrayLiteralExp(loc, tbn->sarrayOf(nargs - i), elements);
- if (tb->ty == Tarray)
- {
- arg = new SliceExp(loc, arg, NULL, NULL);
- arg->type = p->type;
- }
- break;
- }
- case Tclass:
- {
- /* Set arg to be:
- * new Tclass(arg0, arg1, ..., argn)
- */
- Expressions *args = new Expressions();
- args->setDim(nargs - i);
- for (size_t u = i; u < nargs; u++)
- (*args)[u - i] = (*arguments)[u];
- arg = new NewExp(loc, NULL, NULL, p->type, args);
- break;
- }
- default:
- if (!arg)
- {
- error(loc, "not enough arguments");
- return true;
- }
- break;
- }
- arg = expressionSemantic(arg, sc);
- //printf("\targ = '%s'\n", arg->toChars());
- arguments->setDim(i + 1);
- (*arguments)[i] = arg;
- nargs = i + 1;
- done = 1;
- }
-
- L1:
- if (!(p->storageClass & STClazy && p->type->ty == Tvoid))
- {
- bool isRef = (p->storageClass & (STCref | STCout)) != 0;
- if (unsigned char wm = arg->type->deduceWild(p->type, isRef))
- {
- if (wildmatch)
- wildmatch = MODmerge(wildmatch, wm);
- else
- wildmatch = wm;
- //printf("[%d] p = %s, a = %s, wm = %d, wildmatch = %d\n", i, p->type->toChars(), arg->type->toChars(), wm, wildmatch);
- }
- }
- }
- if (done)
- break;
- }
- if ((wildmatch == MODmutable || wildmatch == MODimmutable) &&
- tf->next->hasWild() &&
- (tf->isref || !tf->next->implicitConvTo(tf->next->immutableOf())))
- {
- if (fd)
- {
- /* If the called function may return the reference to
- * outer inout data, it should be rejected.
- *
- * void foo(ref inout(int) x) {
- * ref inout(int) bar(inout(int)) { return x; }
- * struct S { ref inout(int) bar() inout { return x; } }
- * bar(int.init) = 1; // bad!
- * S().bar() = 1; // bad!
- * }
- */
- Dsymbol *s = NULL;
- if (fd->isThis() || fd->isNested())
- s = fd->toParent2();
- for (; s; s = s->toParent2())
- {
- if (AggregateDeclaration *ad = s->isAggregateDeclaration())
- {
- if (ad->isNested())
- continue;
- break;
- }
- if (FuncDeclaration *ff = s->isFuncDeclaration())
- {
- if (((TypeFunction *)ff->type)->iswild)
- goto Linouterr;
-
- if (ff->isNested() || ff->isThis())
- continue;
- }
- break;
- }
- }
- else if (tf->isWild())
- {
- Linouterr:
- const char *s = wildmatch == MODmutable ? "mutable" : MODtoChars(wildmatch);
- error(loc, "modify inout to %s is not allowed inside inout function", s);
- return true;
- }
- }
-
- assert(nargs >= nparams);
- for (size_t i = 0; i < nargs; i++)
- {
- Expression *arg = (*arguments)[i];
- assert(arg);
- if (i < nparams)
- {
- Parameter *p = tf->parameterList[i];
-
- if (!(p->storageClass & STClazy && p->type->ty == Tvoid))
- {
- Type *tprm = p->type;
- if (p->type->hasWild())
- tprm = p->type->substWildTo(wildmatch);
- if (!tprm->equals(arg->type))
- {
- //printf("arg->type = %s, p->type = %s\n", arg->type->toChars(), p->type->toChars());
- arg = arg->implicitCastTo(sc, tprm);
- arg = arg->optimize(WANTvalue, (p->storageClass & (STCref | STCout)) != 0);
- }
- }
- if (p->storageClass & STCref)
- {
- arg = arg->toLvalue(sc, arg);
-
- // Look for mutable misaligned pointer, etc., in @safe mode
- err |= checkUnsafeAccess(sc, arg, false, true);
- }
- else if (p->storageClass & STCout)
- {
- Type *t = arg->type;
- if (!t->isMutable() || !t->isAssignable()) // check blit assignable
- {
- arg->error("cannot modify struct %s with immutable members", arg->toChars());
- err = true;
- }
- else
- {
- // Look for misaligned pointer, etc., in @safe mode
- err |= checkUnsafeAccess(sc, arg, false, true);
- err |= checkDefCtor(arg->loc, t); // t must be default constructible
- }
- arg = arg->toLvalue(sc, arg);
- }
- else if (p->storageClass & STClazy)
- {
- // Convert lazy argument to a delegate
- if (p->type->ty == Tvoid)
- arg = toDelegate(arg, p->type, sc);
- else
- arg = toDelegate(arg, arg->type, sc);
- }
-
- //printf("arg: %s\n", arg->toChars());
- //printf("type: %s\n", arg->type->toChars());
- if (tf->parameterEscapes(p))
- {
- /* Argument value can escape from the called function.
- * Check arg to see if it matters.
- */
- if (global.params.vsafe)
- err |= checkParamArgumentEscape(sc, fd, p->ident, arg, false);
- }
- else
- {
- /* Argument value cannot escape from the called function.
- */
- Expression *a = arg;
- if (a->op == TOKcast)
- a = ((CastExp *)a)->e1;
-
- if (a->op == TOKfunction)
- {
- /* Function literals can only appear once, so if this
- * appearance was scoped, there cannot be any others.
- */
- FuncExp *fe = (FuncExp *)a;
- fe->fd->tookAddressOf = 0;
- }
- else if (a->op == TOKdelegate)
- {
- /* For passing a delegate to a scoped parameter,
- * this doesn't count as taking the address of it.
- * We only worry about 'escaping' references to the function.
- */
- DelegateExp *de = (DelegateExp *)a;
- if (de->e1->op == TOKvar)
- { VarExp *ve = (VarExp *)de->e1;
- FuncDeclaration *f = ve->var->isFuncDeclaration();
- if (f)
- { f->tookAddressOf--;
- //printf("tookAddressOf = %d\n", f->tookAddressOf);
- }
- }
- }
- }
- arg = arg->optimize(WANTvalue, (p->storageClass & (STCref | STCout)) != 0);
- }
- else
- {
- // These will be the trailing ... arguments
-
- // If not D linkage, do promotions
- if (tf->linkage != LINKd)
- {
- // Promote bytes, words, etc., to ints
- arg = integralPromotions(arg, sc);
-
- // Promote floats to doubles
- switch (arg->type->ty)
- {
- case Tfloat32:
- arg = arg->castTo(sc, Type::tfloat64);
- break;
-
- case Timaginary32:
- arg = arg->castTo(sc, Type::timaginary64);
- break;
- }
-
- if (tf->parameterList.varargs == VARARGvariadic)
- {
- const char *p = tf->linkage == LINKc ? "extern(C)" : "extern(C++)";
- if (arg->type->ty == Tarray)
- {
- arg->error("cannot pass dynamic arrays to %s vararg functions", p);
- err = true;
- }
- if (arg->type->ty == Tsarray)
- {
- arg->error("cannot pass static arrays to %s vararg functions", p);
- err = true;
- }
- }
- }
-
- // Do not allow types that need destructors
- if (arg->type->needsDestruction())
- {
- arg->error("cannot pass types that need destruction as variadic arguments");
- err = true;
- }
-
- // Convert static arrays to dynamic arrays
- // BUG: I don't think this is right for D2
- Type *tb = arg->type->toBasetype();
- if (tb->ty == Tsarray)
- {
- TypeSArray *ts = (TypeSArray *)tb;
- Type *ta = ts->next->arrayOf();
- if (ts->size(arg->loc) == 0)
- arg = new NullExp(arg->loc, ta);
- else
- arg = arg->castTo(sc, ta);
- }
- if (tb->ty == Tstruct)
- {
- //arg = callCpCtor(sc, arg);
- }
-
- // Give error for overloaded function addresses
- if (arg->op == TOKsymoff)
- { SymOffExp *se = (SymOffExp *)arg;
- if (se->hasOverloads &&
- !se->var->isFuncDeclaration()->isUnique())
- { arg->error("function %s is overloaded", arg->toChars());
- err = true;
- }
- }
- if (arg->checkValue())
- err = true;
- arg = arg->optimize(WANTvalue);
- }
- (*arguments)[i] = arg;
- }
-
- /* Remaining problems:
- * 1. order of evaluation - some function push L-to-R, others R-to-L. Until we resolve what array assignment does (which is
- * implemented by calling a function) we'll defer this for now.
- * 2. value structs (or static arrays of them) that need to be copy constructed
- * 3. value structs (or static arrays of them) that have destructors, and subsequent arguments that may throw before the
- * function gets called (functions normally destroy their parameters)
- * 2 and 3 are handled by doing the argument construction in 'eprefix' so that if a later argument throws, they are cleaned
- * up properly. Pushing arguments on the stack then cannot fail.
- */
- if (1)
- {
- /* TODO: tackle problem 1)
- */
- const bool leftToRight = true; // TODO: something like !fd.isArrayOp
- if (!leftToRight)
- assert(nargs == nparams); // no variadics for RTL order, as they would probably be evaluated LTR and so add complexity
+ return -1;
+}
- const ptrdiff_t start = (leftToRight ? 0 : (ptrdiff_t)nargs - 1);
- const ptrdiff_t end = (leftToRight ? (ptrdiff_t)nargs : -1);
- const ptrdiff_t step = (leftToRight ? 1 : -1);
+/****************************************
+ * Get TemplateDeclaration enclosing FuncDeclaration.
+ */
- /* Compute indices of last throwing argument and first arg needing destruction.
- * Used to not set up destructors unless an arg needs destruction on a throw
- * in a later argument.
- */
- ptrdiff_t lastthrow = -1;
- ptrdiff_t firstdtor = -1;
- for (ptrdiff_t i = start; i != end; i += step)
+TemplateDeclaration *getFuncTemplateDecl(Dsymbol *s)
+{
+ FuncDeclaration *f = s->isFuncDeclaration();
+ if (f && f->parent)
+ {
+ TemplateInstance *ti = f->parent->isTemplateInstance();
+ if (ti && !ti->isTemplateMixin() &&
+ ti->tempdecl && ((TemplateDeclaration *)ti->tempdecl)->onemember &&
+ ti->tempdecl->ident == f->ident)
{
- Expression *arg = (*arguments)[i];
- if (canThrow(arg, sc->func, false))
- lastthrow = i;
- if (firstdtor == -1 && arg->type->needsDestruction())
- {
- Parameter *p = (i >= (ptrdiff_t)nparams ? NULL : tf->parameterList[i]);
- if (!(p && (p->storageClass & (STClazy | STCref | STCout))))
- firstdtor = i;
- }
+ return (TemplateDeclaration *)ti->tempdecl;
}
+ }
+ return NULL;
+}
- /* Does problem 3) apply to this call?
- */
- const bool needsPrefix = (firstdtor >= 0 && lastthrow >= 0
- && (lastthrow - firstdtor) * step > 0);
+/************************************************
+ * If we want the value of this expression, but do not want to call
+ * the destructor on it.
+ */
- /* If so, initialize 'eprefix' by declaring the gate
+Expression *valueNoDtor(Expression *e)
+{
+ if (e->op == TOKcall)
+ {
+ /* The struct value returned from the function is transferred
+ * so do not call the destructor on it.
+ * Recognize:
+ * ((S _ctmp = S.init), _ctmp).this(...)
+ * and make sure the destructor is not called on _ctmp
+ * BUG: if e is a CommaExp, we should go down the right side.
*/
- VarDeclaration *gate = NULL;
- if (needsPrefix)
- {
- // eprefix => bool __gate [= false]
- Identifier *idtmp = Identifier::generateId("__gate");
- gate = new VarDeclaration(loc, Type::tbool, idtmp, NULL);
- gate->storage_class |= STCtemp | STCctfe | STCvolatile;
- dsymbolSemantic(gate, sc);
-
- Expression *ae = new DeclarationExp(loc, gate);
- eprefix = expressionSemantic(ae, sc);
- }
-
- for (ptrdiff_t i = start; i != end; i += step)
+ CallExp *ce = (CallExp *)e;
+ if (ce->e1->op == TOKdotvar)
{
- Expression *arg = (*arguments)[i];
-
- Parameter *parameter = (i >= (ptrdiff_t)nparams ? NULL : tf->parameterList[i]);
- const bool isRef = (parameter && (parameter->storageClass & (STCref | STCout)));
- const bool isLazy = (parameter && (parameter->storageClass & STClazy));
-
- /* Skip lazy parameters
- */
- if (isLazy)
- continue;
-
- /* Do we have a gate? Then we have a prefix and we're not yet past the last throwing arg.
- * Declare a temporary variable for this arg and append that declaration to 'eprefix',
- * which will implicitly take care of potential problem 2) for this arg.
- * 'eprefix' will therefore finally contain all args up to and including the last
- * potentially throwing arg, excluding all lazy parameters.
- */
- if (gate)
+ DotVarExp *dve = (DotVarExp *)ce->e1;
+ if (dve->var->isCtorDeclaration())
{
- const bool needsDtor = (!isRef && arg->type->needsDestruction() && i != lastthrow);
-
- /* Declare temporary 'auto __pfx = arg' (needsDtor) or 'auto __pfy = arg' (!needsDtor)
- */
- VarDeclaration *tmp = copyToTemp(0,
- needsDtor ? "__pfx" : "__pfy",
- !isRef ? arg : arg->addressOf());
- dsymbolSemantic(tmp, sc);
-
- /* Modify the destructor so it only runs if gate==false, i.e.,
- * only if there was a throw while constructing the args
- */
- if (!needsDtor)
+ // It's a constructor call
+ if (dve->e1->op == TOKcomma)
{
- if (tmp->edtor)
+ CommaExp *comma = (CommaExp *)dve->e1;
+ if (comma->e2->op == TOKvar)
{
- assert(i == lastthrow);
- tmp->edtor = NULL;
+ VarExp *ve = (VarExp *)comma->e2;
+ VarDeclaration *ctmp = ve->var->isVarDeclaration();
+ if (ctmp)
+ {
+ ctmp->storage_class |= STCnodtor;
+ assert(!ce->isLvalue());
+ }
}
}
- else
- {
- // edtor => (__gate || edtor)
- assert(tmp->edtor);
- Expression *e = tmp->edtor;
- e = new LogicalExp(e->loc, TOKoror, new VarExp(e->loc, gate), e);
- tmp->edtor = expressionSemantic(e, sc);
- //printf("edtor: %s\n", tmp->edtor->toChars());
- }
-
- // eprefix => (eprefix, auto __pfx/y = arg)
- DeclarationExp *ae = new DeclarationExp(loc, tmp);
- eprefix = Expression::combine(eprefix, expressionSemantic(ae, sc));
-
- // arg => __pfx/y
- arg = new VarExp(loc, tmp);
- arg = expressionSemantic(arg, sc);
- if (isRef)
- {
- arg = new PtrExp(loc, arg);
- arg = expressionSemantic(arg, sc);
- }
-
- /* Last throwing arg? Then finalize eprefix => (eprefix, gate = true),
- * i.e., disable the dtors right after constructing the last throwing arg.
- * From now on, the callee will take care of destructing the args because
- * the args are implicitly moved into function parameters.
- *
- * Set gate to null to let the next iterations know they don't need to
- * append to eprefix anymore.
- */
- if (i == lastthrow)
- {
- Expression *e = new AssignExp(gate->loc, new VarExp(gate->loc, gate), new IntegerExp(gate->loc, 1, Type::tbool));
- eprefix = Expression::combine(eprefix, expressionSemantic(e, sc));
- gate = NULL;
- }
- }
- else
- {
- /* No gate, no prefix to append to.
- * Handle problem 2) by calling the copy constructor for value structs
- * (or static arrays of them) if appropriate.
- */
- Type *tv = arg->type->baseElemOf();
- if (!isRef && tv->ty == Tstruct)
- arg = doCopyOrMove(sc, arg);
}
-
- (*arguments)[i] = arg;
}
}
- //if (eprefix) printf("eprefix: %s\n", eprefix->toChars());
-
- // If D linkage and variadic, add _arguments[] as first argument
- if (tf->isDstyleVariadic())
+ else if (e->op == TOKvar)
{
- assert(arguments->length >= nparams);
-
- Parameters *args = new Parameters;
- args->setDim(arguments->length - nparams);
- for (size_t i = 0; i < arguments->length - nparams; i++)
+ VarDeclaration *vtmp = ((VarExp *)e)->var->isVarDeclaration();
+ if (vtmp && vtmp->storage_class & STCrvalue)
{
- Parameter *arg = new Parameter(STCin, (*arguments)[nparams + i]->type, NULL, NULL, NULL);
- (*args)[i] = arg;
+ vtmp->storage_class |= STCnodtor;
}
-
- TypeTuple *tup = new TypeTuple(args);
- Expression *e = new TypeidExp(loc, tup);
- e = expressionSemantic(e, sc);
- arguments->insert(0, e);
}
+ return e;
+}
- Type *tret = tf->next;
- if (isCtorCall)
+/*********************************************
+ * If e is an instance of a struct, and that struct has a copy constructor,
+ * rewrite e as:
+ * (tmp = e),tmp
+ * Input:
+ * sc just used to specify the scope of created temporary variable
+ */
+Expression *callCpCtor(Scope *sc, Expression *e)
+{
+ Type *tv = e->type->baseElemOf();
+ if (tv->ty == Tstruct)
{
- //printf("[%s] fd = %s %s, %d %d %d\n", loc.toChars(), fd->toChars(), fd->type->toChars(),
- // wildmatch, tf->isWild(), fd->isolateReturn());
- if (!tthis)
- {
- assert(sc->intypeof || global.errors);
- tthis = fd->isThis()->type->addMod(fd->type->mod);
- }
- if (tf->isWild() && !fd->isolateReturn())
+ StructDeclaration *sd = ((TypeStruct *)tv)->sym;
+ if (sd->postblit)
{
- if (wildmatch)
- tret = tret->substWildTo(wildmatch);
- int offset;
- if (!tret->implicitConvTo(tthis) &&
- !(MODimplicitConv(tret->mod, tthis->mod) && tret->isBaseOf(tthis, &offset) && offset == 0))
- {
- const char* s1 = tret ->isNaked() ? " mutable" : tret ->modToChars();
- const char* s2 = tthis->isNaked() ? " mutable" : tthis->modToChars();
- ::error(loc, "inout constructor %s creates%s object, not%s",
- fd->toPrettyChars(), s1, s2);
- err = true;
- }
+ /* Create a variable tmp, and replace the argument e with:
+ * (tmp = e),tmp
+ * and let AssignExp() handle the construction.
+ * This is not the most efficent, ideally tmp would be constructed
+ * directly onto the stack.
+ */
+ VarDeclaration *tmp = copyToTemp(STCrvalue, "__copytmp", e);
+ tmp->storage_class |= STCnodtor;
+ dsymbolSemantic(tmp, sc);
+ Expression *de = new DeclarationExp(e->loc, tmp);
+ Expression *ve = new VarExp(e->loc, tmp);
+ de->type = Type::tvoid;
+ ve->type = e->type;
+ e = Expression::combine(de, ve);
}
- tret = tthis;
}
- else if (wildmatch && tret)
+ return e;
+}
+
+/************************************************
+ * Handle the postblit call on lvalue, or the move of rvalue.
+ */
+Expression *doCopyOrMove(Scope *sc, Expression *e)
+{
+ if (e->op == TOKquestion)
+ {
+ CondExp *ce = (CondExp *)e;
+ ce->e1 = doCopyOrMove(sc, ce->e1);
+ ce->e2 = doCopyOrMove(sc, ce->e2);
+ }
+ else
{
- /* Adjust function return type based on wildmatch
- */
- //printf("wildmatch = x%x, tret = %s\n", wildmatch, tret->toChars());
- tret = tret->substWildTo(wildmatch);
+ e = e->isLvalue() ? callCpCtor(sc, e) : valueNoDtor(e);
}
- *prettype = tret;
- *peprefix = eprefix;
- return (err || olderrors != global.errors);
+ return e;
}
/******************************** Expression **************************/
@@ -5288,8 +3706,10 @@ MATCH FuncExp::matchType(Type *to, Scope *sc, FuncExp **presult, int flag)
}
else if (!flag)
{
+ const char *ts[2];
+ toAutoQualChars(ts, tx, to);
error("cannot implicitly convert expression (%s) of type %s to %s",
- toChars(), tx->toChars(), to->toChars());
+ toChars(), ts[0], ts[1]);
}
return m;
}
@@ -5644,11 +4064,17 @@ Expression *BinExp::incompatibleTypes()
error("incompatible types for ((%s) %s (%s)): cannot use `%s` with types",
e1->toChars(), Token::toChars(thisOp), e2->toChars(), Token::toChars(op));
}
+ else if (e1->type->equals(e2->type))
+ {
+ error("incompatible types for ((%s) %s (%s)): both operands are of type `%s`",
+ e1->toChars(), Token::toChars(thisOp), e2->toChars(), e1->type->toChars());
+ }
else
{
+ const char *ts[2];
+ toAutoQualChars(ts, e1->type, e2->type);
error("incompatible types for ((%s) %s (%s)): `%s` and `%s`",
- e1->toChars(), Token::toChars(thisOp), e2->toChars(),
- e1->type->toChars(), e2->type->toChars());
+ e1->toChars(), Token::toChars(thisOp), e2->toChars(), ts[0], ts[1]);
}
return new ErrorExp();
}
@@ -5693,9 +4119,36 @@ Expression *BinAssignExp::modifiableLvalue(Scope *sc, Expression *)
/************************************************************/
-CompileExp::CompileExp(Loc loc, Expression *e)
- : UnaExp(loc, TOKmixin, sizeof(CompileExp), e)
+CompileExp::CompileExp(Loc loc, Expressions *exps)
+ : Expression(loc, TOKmixin, sizeof(CompileExp))
+{
+ this->exps = exps;
+}
+
+Expression *CompileExp::syntaxCopy()
+{
+ return new CompileExp(loc, arraySyntaxCopy(exps));
+}
+
+bool CompileExp::equals(RootObject *o)
{
+ if (this == o)
+ return true;
+ if (o && o->dyncast() == DYNCAST_EXPRESSION && ((Expression *)o)->op == TOKmixin)
+ {
+ CompileExp *ce = (CompileExp *)o;
+ if (exps->length != ce->exps->length)
+ return false;
+ for (size_t i = 0; i < exps->length; i++)
+ {
+ Expression *e1 = (*exps)[i];
+ Expression *e2 = (*ce->exps)[i];
+ if (e1 != e2 && (!e1 || !e2 || !e1->equals(e2)))
+ return false;
+ }
+ return true;
+ }
+ return false;
}
/************************************************************/
@@ -6362,64 +4815,6 @@ ArrayLengthExp::ArrayLengthExp(Loc loc, Expression *e1)
{
}
-Expression *opAssignToOp(Loc loc, TOK op, Expression *e1, Expression *e2)
-{ Expression *e;
-
- switch (op)
- {
- case TOKaddass: e = new AddExp(loc, e1, e2); break;
- case TOKminass: e = new MinExp(loc, e1, e2); break;
- case TOKmulass: e = new MulExp(loc, e1, e2); break;
- case TOKdivass: e = new DivExp(loc, e1, e2); break;
- case TOKmodass: e = new ModExp(loc, e1, e2); break;
- case TOKandass: e = new AndExp(loc, e1, e2); break;
- case TOKorass: e = new OrExp (loc, e1, e2); break;
- case TOKxorass: e = new XorExp(loc, e1, e2); break;
- case TOKshlass: e = new ShlExp(loc, e1, e2); break;
- case TOKshrass: e = new ShrExp(loc, e1, e2); break;
- case TOKushrass: e = new UshrExp(loc, e1, e2); break;
- default: assert(0);
- }
- return e;
-}
-
-/*********************
- * Rewrite:
- * array.length op= e2
- * as:
- * array.length = array.length op e2
- * or:
- * auto tmp = &array;
- * (*tmp).length = (*tmp).length op e2
- */
-
-Expression *ArrayLengthExp::rewriteOpAssign(BinExp *exp)
-{
- Expression *e;
-
- assert(exp->e1->op == TOKarraylength);
- ArrayLengthExp *ale = (ArrayLengthExp *)exp->e1;
- if (ale->e1->op == TOKvar)
- {
- e = opAssignToOp(exp->loc, exp->op, ale, exp->e2);
- e = new AssignExp(exp->loc, ale->syntaxCopy(), e);
- }
- else
- {
- /* auto tmp = &array;
- * (*tmp).length = (*tmp).length op e2
- */
- VarDeclaration *tmp = copyToTemp(0, "__arraylength", new AddrExp(ale->loc, ale->e1));
-
- Expression *e1 = new ArrayLengthExp(ale->loc, new PtrExp(ale->loc, new VarExp(ale->loc, tmp)));
- Expression *elvalue = e1->syntaxCopy();
- e = opAssignToOp(exp->loc, exp->op, e1, exp->e2);
- e = new AssignExp(exp->loc, elvalue, e);
- e = new CommaExp(exp->loc, new DeclarationExp(ale->loc, tmp), e);
- }
- return e;
-}
-
/*********************** IntervalExp ********************************/
// Mainly just a placeholder
@@ -7248,203 +5643,6 @@ Expression *PrettyFuncInitExp::resolveLoc(Loc loc, Scope *sc)
return e;
}
-/****************************************************************/
-
-Expression *extractOpDollarSideEffect(Scope *sc, UnaExp *ue)
-{
- Expression *e0;
- Expression *e1 = Expression::extractLast(ue->e1, &e0);
- // Bugzilla 12585: Extract the side effect part if ue->e1 is comma.
-
- if (!isTrivialExp(e1))
- {
- /* Even if opDollar is needed, 'e1' should be evaluate only once. So
- * Rewrite:
- * e1.opIndex( ... use of $ ... )
- * e1.opSlice( ... use of $ ... )
- * as:
- * (ref __dop = e1, __dop).opIndex( ... __dop.opDollar ...)
- * (ref __dop = e1, __dop).opSlice( ... __dop.opDollar ...)
- */
- e1 = extractSideEffect(sc, "__dop", &e0, e1, false);
- assert(e1->op == TOKvar);
- VarExp *ve = (VarExp *)e1;
- ve->var->storage_class |= STCexptemp; // lifetime limited to expression
- }
- ue->e1 = e1;
- return e0;
-}
-
-/**************************************
- * Runs semantic on ae->arguments. Declares temporary variables
- * if '$' was used.
- */
-Expression *resolveOpDollar(Scope *sc, ArrayExp *ae, Expression **pe0)
-{
- assert(!ae->lengthVar);
-
- *pe0 = NULL;
-
- AggregateDeclaration *ad = isAggregate(ae->e1->type);
- Dsymbol *slice = search_function(ad, Id::slice);
- //printf("slice = %s %s\n", slice->kind(), slice->toChars());
-
- for (size_t i = 0; i < ae->arguments->length; i++)
- {
- if (i == 0)
- *pe0 = extractOpDollarSideEffect(sc, ae);
-
- Expression *e = (*ae->arguments)[i];
- if (e->op == TOKinterval && !(slice && slice->isTemplateDeclaration()))
- {
- Lfallback:
- if (ae->arguments->length == 1)
- return NULL;
- ae->error("multi-dimensional slicing requires template opSlice");
- return new ErrorExp();
- }
- //printf("[%d] e = %s\n", i, e->toChars());
-
- // Create scope for '$' variable for this dimension
- ArrayScopeSymbol *sym = new ArrayScopeSymbol(sc, ae);
- sym->loc = ae->loc;
- sym->parent = sc->scopesym;
- sc = sc->push(sym);
- ae->lengthVar = NULL; // Create it only if required
- ae->currentDimension = i; // Dimension for $, if required
-
- e = expressionSemantic(e, sc);
- e = resolveProperties(sc, e);
-
- if (ae->lengthVar && sc->func)
- {
- // If $ was used, declare it now
- Expression *de = new DeclarationExp(ae->loc, ae->lengthVar);
- de = expressionSemantic(de, sc);
- *pe0 = Expression::combine(*pe0, de);
- }
- sc = sc->pop();
-
- if (e->op == TOKinterval)
- {
- IntervalExp *ie = (IntervalExp *)e;
-
- Objects *tiargs = new Objects();
- Expression *edim = new IntegerExp(ae->loc, i, Type::tsize_t);
- edim = expressionSemantic(edim, sc);
- tiargs->push(edim);
-
- Expressions *fargs = new Expressions();
- fargs->push(ie->lwr);
- fargs->push(ie->upr);
-
- unsigned xerrors = global.startGagging();
- sc = sc->push();
- FuncDeclaration *fslice = resolveFuncCall(ae->loc, sc, slice, tiargs, ae->e1->type, fargs, 1);
- sc = sc->pop();
- global.endGagging(xerrors);
- if (!fslice)
- goto Lfallback;
-
- e = new DotTemplateInstanceExp(ae->loc, ae->e1, slice->ident, tiargs);
- e = new CallExp(ae->loc, e, fargs);
- e = expressionSemantic(e, sc);
- }
-
- if (!e->type)
- {
- ae->error("%s has no value", e->toChars());
- e = new ErrorExp();
- }
- if (e->op == TOKerror)
- return e;
-
- (*ae->arguments)[i] = e;
- }
-
- return ae;
-}
-
-/***********************************************************
- * Resolve `exp` as a compile-time known string.
- * Params:
- * sc = scope
- * exp = Expression which expected as a string
- * s = What the string is expected for, will be used in error diagnostic.
- * Returns:
- * String literal, or `null` if error happens.
- */
-StringExp *semanticString(Scope *sc, Expression *exp, const char *s)
-{
- sc = sc->startCTFE();
- exp = expressionSemantic(exp, sc);
- exp = resolveProperties(sc, exp);
- sc = sc->endCTFE();
-
- if (exp->op == TOKerror)
- return NULL;
-
- Expression *e = exp;
- if (exp->type->isString())
- {
- e = e->ctfeInterpret();
- if (e->op == TOKerror)
- return NULL;
- }
-
- StringExp *se = e->toStringExp();
- if (!se)
- {
- exp->error("string expected for %s, not (%s) of type %s",
- s, exp->toChars(), exp->type->toChars());
- return NULL;
- }
- return se;
-}
-
-/**************************************
- * Runs semantic on se->lwr and se->upr. Declares a temporary variable
- * if '$' was used.
- */
-Expression *resolveOpDollar(Scope *sc, ArrayExp *ae, IntervalExp *ie, Expression **pe0)
-{
- //assert(!ae->lengthVar);
- if (!ie)
- return ae;
-
- VarDeclaration *lengthVar = ae->lengthVar;
-
- // create scope for '$'
- ArrayScopeSymbol *sym = new ArrayScopeSymbol(sc, ae);
- sym->loc = ae->loc;
- sym->parent = sc->scopesym;
- sc = sc->push(sym);
-
- for (size_t i = 0; i < 2; ++i)
- {
- Expression *e = i == 0 ? ie->lwr : ie->upr;
- e = expressionSemantic(e, sc);
- e = resolveProperties(sc, e);
- if (!e->type)
- {
- ae->error("%s has no value", e->toChars());
- return new ErrorExp();
- }
- (i == 0 ? ie->lwr : ie->upr) = e;
- }
-
- if (lengthVar != ae->lengthVar && sc->func)
- {
- // If $ was used, declare it now
- Expression *de = new DeclarationExp(ae->loc, ae->lengthVar);
- de = expressionSemantic(de, sc);
- *pe0 = Expression::combine(*pe0, de);
- }
- sc = sc->pop();
-
- return ae;
-}
-
Expression *BinExp::reorderSettingAAElem(Scope *sc)
{
BinExp *be = this;
@@ -883,10 +883,14 @@ public:
/****************************************************************/
-class CompileExp : public UnaExp
+class CompileExp : public Expression
{
public:
- CompileExp(Loc loc, Expression *e);
+ Expressions *exps;
+
+ CompileExp(Loc loc, Expressions *exps);
+ Expression *syntaxCopy();
+ bool equals(RootObject *o);
void accept(Visitor *v) { v->visit(this); }
};
@@ -1124,7 +1128,6 @@ class ArrayLengthExp : public UnaExp
public:
ArrayLengthExp(Loc loc, Expression *e1);
- static Expression *rewriteOpAssign(BinExp *exp);
void accept(Visitor *v) { v->visit(this); }
};
@@ -47,26 +47,1252 @@ bool symbolIsVisible(Scope *sc, Dsymbol *s);
VarDeclaration *copyToTemp(StorageClass stc, const char *name, Expression *e);
Expression *extractSideEffect(Scope *sc, const char *name, Expression **e0, Expression *e, bool alwaysCopy = false);
Type *getTypeInfoType(Loc loc, Type *t, Scope *sc);
+char *MODtoChars(MOD mod);
bool MODimplicitConv(MOD modfrom, MOD modto);
+MOD MODmerge(MOD mod1, MOD mod2);
MATCH MODmethodConv(MOD modfrom, MOD modto);
void MODMatchToBuffer(OutBuffer *buf, unsigned char lhsMod, unsigned char rhsMod);
void unSpeculative(Scope *sc, RootObject *o);
-bool arrayExpressionToCommonType(Scope *sc, Expressions *exps, Type **pt);
-bool checkDefCtor(Loc loc, Type *t);
bool isDotOpDispatch(Expression *e);
-bool functionParameters(Loc loc, Scope *sc, TypeFunction *tf, Type *tthis, Expressions *arguments, FuncDeclaration *fd, Type **prettype, Expression **peprefix);
-Expression *getRightThis(Loc loc, Scope *sc, AggregateDeclaration *ad, Expression *e1, Declaration *var, int flag = 0);
bool isNeedThisScope(Scope *sc, Declaration *d);
-Expression *resolveUFCS(Scope *sc, CallExp *ce);
bool checkUnsafeAccess(Scope *sc, Expression *e, bool readonly, bool printmsg);
bool isSafeCast(Expression *e, Type *tfrom, Type *tto);
FuncDeclaration *isFuncAddress(Expression *e, bool *hasOverloads = NULL);
Expression *callCpCtor(Scope *sc, Expression *e);
Expression *resolve(Loc loc, Scope *sc, Dsymbol *s, bool hasOverloads);
-Expression *resolveUFCSProperties(Scope *sc, Expression *e1, Expression *e2 = NULL);
-Expression *resolvePropertiesX(Scope *sc, Expression *e1, Expression *e2 = NULL);
+
+bool checkPrintfFormat(const Loc &loc, const char *format, Expressions &args, bool isVa_list);
+bool checkScanfFormat(const Loc &loc, const char *format, Expressions &args, bool isVa_list);
+
+/********************************************************
+ * Perform semantic analysis and CTFE on expressions to produce
+ * a string.
+ * Params:
+ * buf = append generated string to buffer
+ * sc = context
+ * exps = array of Expressions
+ * Returns:
+ * true on error
+ */
+bool expressionsToString(OutBuffer &buf, Scope *sc, Expressions *exps)
+{
+ if (!exps)
+ return false;
+
+ for (size_t i = 0; i < exps->length; i++)
+ {
+ Expression *ex = (*exps)[i];
+ if (!ex)
+ continue;
+ Scope *sc2 = sc->startCTFE();
+ Expression *e2 = expressionSemantic(ex, sc2);
+ Expression *e3 = resolveProperties(sc2, e2);
+ sc2->endCTFE();
+
+ // allowed to contain types as well as expressions
+ Expression *e4 = ctfeInterpretForPragmaMsg(e3);
+ if (!e4 || e4->op == TOKerror)
+ return true;
+
+ // expand tuple
+ if (TupleExp *te = e4->isTupleExp())
+ {
+ if (expressionsToString(buf, sc, te->exps))
+ return true;
+ continue;
+ }
+ // char literals exp `.toStringExp` return `null` but we cant override it
+ // because in most contexts we don't want the conversion to succeed.
+ IntegerExp *ie = e4->isIntegerExp();
+ const TY ty = (ie && ie->type) ? ie->type->ty : (TY)Terror;
+ if (ty == Tchar || ty == Twchar || ty == Tdchar)
+ {
+ TypeSArray *tsa = new TypeSArray(ie->type, new IntegerExp(ex->loc, 1, Type::tint32));
+ e4 = new ArrayLiteralExp(ex->loc, tsa, ie);
+ }
+
+ if (StringExp *se = e4->toStringExp())
+ buf.writestring(se->toUTF8(sc)->toPtr());
+ else
+ buf.writestring(e4->toChars());
+ }
+ return false;
+}
+
+/***********************************************************
+ * Resolve `exp` as a compile-time known string.
+ * Params:
+ * sc = scope
+ * exp = Expression which expected as a string
+ * s = What the string is expected for, will be used in error diagnostic.
+ * Returns:
+ * String literal, or `null` if error happens.
+ */
+StringExp *semanticString(Scope *sc, Expression *exp, const char *s)
+{
+ sc = sc->startCTFE();
+ exp = expressionSemantic(exp, sc);
+ exp = resolveProperties(sc, exp);
+ sc = sc->endCTFE();
+
+ if (exp->op == TOKerror)
+ return NULL;
+
+ Expression *e = exp;
+ if (exp->type->isString())
+ {
+ e = e->ctfeInterpret();
+ if (e->op == TOKerror)
+ return NULL;
+ }
+
+ StringExp *se = e->toStringExp();
+ if (!se)
+ {
+ exp->error("string expected for %s, not (%s) of type %s",
+ s, exp->toChars(), exp->type->toChars());
+ return NULL;
+ }
+ return se;
+}
+
+/****************************************************************/
+
+static Expression *extractOpDollarSideEffect(Scope *sc, UnaExp *ue)
+{
+ Expression *e0;
+ Expression *e1 = Expression::extractLast(ue->e1, &e0);
+ // Bugzilla 12585: Extract the side effect part if ue->e1 is comma.
+
+ if (!isTrivialExp(e1))
+ {
+ /* Even if opDollar is needed, 'e1' should be evaluate only once. So
+ * Rewrite:
+ * e1.opIndex( ... use of $ ... )
+ * e1.opSlice( ... use of $ ... )
+ * as:
+ * (ref __dop = e1, __dop).opIndex( ... __dop.opDollar ...)
+ * (ref __dop = e1, __dop).opSlice( ... __dop.opDollar ...)
+ */
+ e1 = extractSideEffect(sc, "__dop", &e0, e1, false);
+ assert(e1->op == TOKvar);
+ VarExp *ve = (VarExp *)e1;
+ ve->var->storage_class |= STCexptemp; // lifetime limited to expression
+ }
+ ue->e1 = e1;
+ return e0;
+}
+
+/**************************************
+ * Runs semantic on ae->arguments. Declares temporary variables
+ * if '$' was used.
+ */
+Expression *resolveOpDollar(Scope *sc, ArrayExp *ae, Expression **pe0)
+{
+ assert(!ae->lengthVar);
+
+ *pe0 = NULL;
+
+ AggregateDeclaration *ad = isAggregate(ae->e1->type);
+ Dsymbol *slice = search_function(ad, Id::slice);
+ //printf("slice = %s %s\n", slice->kind(), slice->toChars());
+
+ for (size_t i = 0; i < ae->arguments->length; i++)
+ {
+ if (i == 0)
+ *pe0 = extractOpDollarSideEffect(sc, ae);
+
+ Expression *e = (*ae->arguments)[i];
+ if (e->op == TOKinterval && !(slice && slice->isTemplateDeclaration()))
+ {
+ Lfallback:
+ if (ae->arguments->length == 1)
+ return NULL;
+ ae->error("multi-dimensional slicing requires template opSlice");
+ return new ErrorExp();
+ }
+ //printf("[%d] e = %s\n", i, e->toChars());
+
+ // Create scope for '$' variable for this dimension
+ ArrayScopeSymbol *sym = new ArrayScopeSymbol(sc, ae);
+ sym->loc = ae->loc;
+ sym->parent = sc->scopesym;
+ sc = sc->push(sym);
+ ae->lengthVar = NULL; // Create it only if required
+ ae->currentDimension = i; // Dimension for $, if required
+
+ e = expressionSemantic(e, sc);
+ e = resolveProperties(sc, e);
+
+ if (ae->lengthVar && sc->func)
+ {
+ // If $ was used, declare it now
+ Expression *de = new DeclarationExp(ae->loc, ae->lengthVar);
+ de = expressionSemantic(de, sc);
+ *pe0 = Expression::combine(*pe0, de);
+ }
+ sc = sc->pop();
+
+ if (e->op == TOKinterval)
+ {
+ IntervalExp *ie = (IntervalExp *)e;
+
+ Objects *tiargs = new Objects();
+ Expression *edim = new IntegerExp(ae->loc, i, Type::tsize_t);
+ edim = expressionSemantic(edim, sc);
+ tiargs->push(edim);
+
+ Expressions *fargs = new Expressions();
+ fargs->push(ie->lwr);
+ fargs->push(ie->upr);
+
+ unsigned xerrors = global.startGagging();
+ sc = sc->push();
+ FuncDeclaration *fslice = resolveFuncCall(ae->loc, sc, slice, tiargs, ae->e1->type, fargs, 1);
+ sc = sc->pop();
+ global.endGagging(xerrors);
+ if (!fslice)
+ goto Lfallback;
+
+ e = new DotTemplateInstanceExp(ae->loc, ae->e1, slice->ident, tiargs);
+ e = new CallExp(ae->loc, e, fargs);
+ e = expressionSemantic(e, sc);
+ }
+
+ if (!e->type)
+ {
+ ae->error("%s has no value", e->toChars());
+ e = new ErrorExp();
+ }
+ if (e->op == TOKerror)
+ return e;
+
+ (*ae->arguments)[i] = e;
+ }
+
+ return ae;
+}
+
+/**************************************
+ * Runs semantic on se->lwr and se->upr. Declares a temporary variable
+ * if '$' was used.
+ */
+Expression *resolveOpDollar(Scope *sc, ArrayExp *ae, IntervalExp *ie, Expression **pe0)
+{
+ //assert(!ae->lengthVar);
+ if (!ie)
+ return ae;
+
+ VarDeclaration *lengthVar = ae->lengthVar;
+
+ // create scope for '$'
+ ArrayScopeSymbol *sym = new ArrayScopeSymbol(sc, ae);
+ sym->loc = ae->loc;
+ sym->parent = sc->scopesym;
+ sc = sc->push(sym);
+
+ for (size_t i = 0; i < 2; ++i)
+ {
+ Expression *e = i == 0 ? ie->lwr : ie->upr;
+ e = expressionSemantic(e, sc);
+ e = resolveProperties(sc, e);
+ if (!e->type)
+ {
+ ae->error("%s has no value", e->toChars());
+ return new ErrorExp();
+ }
+ (i == 0 ? ie->lwr : ie->upr) = e;
+ }
+
+ if (lengthVar != ae->lengthVar && sc->func)
+ {
+ // If $ was used, declare it now
+ Expression *de = new DeclarationExp(ae->loc, ae->lengthVar);
+ de = expressionSemantic(de, sc);
+ *pe0 = Expression::combine(*pe0, de);
+ }
+ sc = sc->pop();
+
+ return ae;
+}
+
+/******************************
+ * Perform semantic() on an array of Expressions.
+ */
+
+bool arrayExpressionSemantic(Expressions *exps, Scope *sc, bool preserveErrors)
+{
+ bool err = false;
+ if (exps)
+ {
+ for (size_t i = 0; i < exps->length; i++)
+ {
+ Expression *e = (*exps)[i];
+ if (e)
+ {
+ e = expressionSemantic(e, sc);
+ if (e->op == TOKerror)
+ err = true;
+ if (preserveErrors || e->op != TOKerror)
+ (*exps)[i] = e;
+ }
+ }
+ }
+ return err;
+}
+
+/******************************
+ * Check the tail CallExp is really property function call.
+ */
+static bool checkPropertyCall(Expression *e)
+{
+ while (e->op == TOKcomma)
+ e = ((CommaExp *)e)->e2;
+
+ if (e->op == TOKcall)
+ {
+ CallExp *ce = (CallExp *)e;
+ TypeFunction *tf;
+ if (ce->f)
+ {
+ tf = (TypeFunction *)ce->f->type;
+ /* If a forward reference to ce->f, try to resolve it
+ */
+ if (!tf->deco && ce->f->semanticRun < PASSsemanticdone)
+ {
+ dsymbolSemantic(ce->f, NULL);
+ tf = (TypeFunction *)ce->f->type;
+ }
+ }
+ else if (ce->e1->type->ty == Tfunction)
+ tf = (TypeFunction *)ce->e1->type;
+ else if (ce->e1->type->ty == Tdelegate)
+ tf = (TypeFunction *)ce->e1->type->nextOf();
+ else if (ce->e1->type->ty == Tpointer && ce->e1->type->nextOf()->ty == Tfunction)
+ tf = (TypeFunction *)ce->e1->type->nextOf();
+ else
+ assert(0);
+ }
+ return false;
+}
+
+// TODO: merge with Scope::search::searchScopes()
+static Dsymbol *searchScopes(Scope *sc, Loc loc, Identifier *ident, int flags)
+{
+ Dsymbol *s = NULL;
+ for (Scope *scx = sc; scx; scx = scx->enclosing)
+ {
+ if (!scx->scopesym)
+ continue;
+ if (scx->scopesym->isModule())
+ flags |= SearchUnqualifiedModule; // tell Module.search() that SearchLocalsOnly is to be obeyed
+ s = scx->scopesym->search(loc, ident, flags);
+ if (s)
+ {
+ // overload set contains only module scope symbols.
+ if (s->isOverloadSet())
+ break;
+ // selective/renamed imports also be picked up
+ if (AliasDeclaration *ad = s->isAliasDeclaration())
+ {
+ if (ad->_import)
+ break;
+ }
+ // See only module scope symbols for UFCS target.
+ Dsymbol *p = s->toParent2();
+ if (p && p->isModule())
+ break;
+ }
+ s = NULL;
+
+ // Stop when we hit a module, but keep going if that is not just under the global scope
+ if (scx->scopesym->isModule() && !(scx->enclosing && !scx->enclosing->enclosing))
+ break;
+ }
+ return s;
+}
+
+/******************************
+ * Find symbol in accordance with the UFCS name look up rule
+ */
+
+static Expression *searchUFCS(Scope *sc, UnaExp *ue, Identifier *ident)
+{
+ //printf("searchUFCS(ident = %s)\n", ident->toChars());
+ Loc loc = ue->loc;
+ int flags = 0;
+ Dsymbol *s = NULL;
+
+ if (sc->flags & SCOPEignoresymbolvisibility)
+ flags |= IgnoreSymbolVisibility;
+
+ // First look in local scopes
+ s = searchScopes(sc, loc, ident, flags | SearchLocalsOnly);
+ if (!s)
+ {
+ // Second look in imported modules
+ s = searchScopes(sc, loc, ident, flags | SearchImportsOnly);
+ }
+
+ if (!s)
+ return ue->e1->type->Type::getProperty(loc, ident, 0);
+
+ FuncDeclaration *f = s->isFuncDeclaration();
+ if (f)
+ {
+ TemplateDeclaration *td = getFuncTemplateDecl(f);
+ if (td)
+ {
+ if (td->overroot)
+ td = td->overroot;
+ s = td;
+ }
+ }
+
+ if (ue->op == TOKdotti)
+ {
+ DotTemplateInstanceExp *dti = (DotTemplateInstanceExp *)ue;
+ TemplateInstance *ti = new TemplateInstance(loc, s->ident);
+ ti->tiargs = dti->ti->tiargs; // for better diagnostic message
+ if (!ti->updateTempDecl(sc, s))
+ return new ErrorExp();
+ return new ScopeExp(loc, ti);
+ }
+ else
+ {
+ //printf("-searchUFCS() %s\n", s->toChars());
+ return new DsymbolExp(loc, s);
+ }
+}
+
+/******************************
+ * Pull out callable entity with UFCS.
+ */
+
+static Expression *resolveUFCS(Scope *sc, CallExp *ce)
+{
+ Loc loc = ce->loc;
+ Expression *eleft;
+ Expression *e;
+
+ if (ce->e1->op == TOKdotid)
+ {
+ DotIdExp *die = (DotIdExp *)ce->e1;
+ Identifier *ident = die->ident;
+
+ Expression *ex = semanticX(die, sc);
+ if (ex != die)
+ {
+ ce->e1 = ex;
+ return NULL;
+ }
+ eleft = die->e1;
+
+ Type *t = eleft->type->toBasetype();
+ if (t->ty == Tarray || t->ty == Tsarray ||
+ t->ty == Tnull || (t->isTypeBasic() && t->ty != Tvoid))
+ {
+ /* Built-in types and arrays have no callable properties, so do shortcut.
+ * It is necessary in: e.init()
+ */
+ }
+ else if (t->ty == Taarray)
+ {
+ if (ident == Id::remove)
+ {
+ /* Transform:
+ * aa.remove(arg) into delete aa[arg]
+ */
+ if (!ce->arguments || ce->arguments->length != 1)
+ {
+ ce->error("expected key as argument to aa.remove()");
+ return new ErrorExp();
+ }
+ if (!eleft->type->isMutable())
+ {
+ ce->error("cannot remove key from %s associative array %s",
+ MODtoChars(t->mod), eleft->toChars());
+ return new ErrorExp();
+ }
+ Expression *key = (*ce->arguments)[0];
+ key = expressionSemantic(key, sc);
+ key = resolveProperties(sc, key);
+
+ TypeAArray *taa = (TypeAArray *)t;
+ key = key->implicitCastTo(sc, taa->index);
+
+ if (key->checkValue())
+ return new ErrorExp();
+
+ semanticTypeInfo(sc, taa->index);
+
+ return new RemoveExp(loc, eleft, key);
+ }
+ }
+ else
+ {
+ if (Expression *ey = semanticY(die, sc, 1))
+ {
+ if (ey->op == TOKerror)
+ return ey;
+ ce->e1 = ey;
+ if (isDotOpDispatch(ey))
+ {
+ unsigned errors = global.startGagging();
+ e = expressionSemantic(ce->syntaxCopy(), sc);
+ if (!global.endGagging(errors))
+ return e;
+ /* fall down to UFCS */
+ }
+ else
+ return NULL;
+ }
+ }
+ e = searchUFCS(sc, die, ident);
+ }
+ else if (ce->e1->op == TOKdotti)
+ {
+ DotTemplateInstanceExp *dti = (DotTemplateInstanceExp *)ce->e1;
+ if (Expression *ey = semanticY(dti, sc, 1))
+ {
+ ce->e1 = ey;
+ return NULL;
+ }
+ eleft = dti->e1;
+ e = searchUFCS(sc, dti, dti->ti->name);
+ }
+ else
+ return NULL;
+
+ // Rewrite
+ ce->e1 = e;
+ if (!ce->arguments)
+ ce->arguments = new Expressions();
+ ce->arguments->shift(eleft);
+
+ return NULL;
+}
+
+/******************************
+ * Pull out property with UFCS.
+ */
+
+static Expression *resolveUFCSProperties(Scope *sc, Expression *e1, Expression *e2 = NULL)
+{
+ Loc loc = e1->loc;
+ Expression *eleft;
+ Expression *e;
+
+ if (e1->op == TOKdotid)
+ {
+ DotIdExp *die = (DotIdExp *)e1;
+ eleft = die->e1;
+ e = searchUFCS(sc, die, die->ident);
+ }
+ else if (e1->op == TOKdotti)
+ {
+ DotTemplateInstanceExp *dti;
+ dti = (DotTemplateInstanceExp *)e1;
+ eleft = dti->e1;
+ e = searchUFCS(sc, dti, dti->ti->name);
+ }
+ else
+ return NULL;
+
+ if (e == NULL)
+ return NULL;
+
+ // Rewrite
+ if (e2)
+ {
+ // run semantic without gagging
+ e2 = expressionSemantic(e2, sc);
+
+ /* f(e1) = e2
+ */
+ Expression *ex = e->copy();
+ Expressions *a1 = new Expressions();
+ a1->setDim(1);
+ (*a1)[0] = eleft;
+ ex = new CallExp(loc, ex, a1);
+ ex = trySemantic(ex, sc);
+
+ /* f(e1, e2)
+ */
+ Expressions *a2 = new Expressions();
+ a2->setDim(2);
+ (*a2)[0] = eleft;
+ (*a2)[1] = e2;
+ e = new CallExp(loc, e, a2);
+ if (ex)
+ { // if fallback setter exists, gag errors
+ e = trySemantic(e, sc);
+ if (!e)
+ { checkPropertyCall(ex);
+ ex = new AssignExp(loc, ex, e2);
+ return expressionSemantic(ex, sc);
+ }
+ }
+ else
+ { // strict setter prints errors if fails
+ e = expressionSemantic(e, sc);
+ }
+ checkPropertyCall(e);
+ return e;
+ }
+ else
+ {
+ /* f(e1)
+ */
+ Expressions *arguments = new Expressions();
+ arguments->setDim(1);
+ (*arguments)[0] = eleft;
+ e = new CallExp(loc, e, arguments);
+ e = expressionSemantic(e, sc);
+ checkPropertyCall(e);
+ return expressionSemantic(e, sc);
+ }
+}
+
+/******************************
+ * If e1 is a property function (template), resolve it.
+ */
+
+Expression *resolvePropertiesOnly(Scope *sc, Expression *e1)
+{
+ //printf("e1 = %s %s\n", Token::toChars(e1->op), e1->toChars());
+ OverloadSet *os;
+ FuncDeclaration *fd;
+ TemplateDeclaration *td;
+
+ if (e1->op == TOKdot)
+ {
+ DotExp *de = (DotExp *)e1;
+ if (de->e2->op == TOKoverloadset)
+ {
+ os = ((OverExp *)de->e2)->vars;
+ goto Los;
+ }
+ }
+ else if (e1->op == TOKoverloadset)
+ {
+ os = ((OverExp *)e1)->vars;
+ Los:
+ assert(os);
+ for (size_t i = 0; i < os->a.length; i++)
+ {
+ Dsymbol *s = os->a[i];
+ fd = s->isFuncDeclaration();
+ td = s->isTemplateDeclaration();
+ if (fd)
+ {
+ if (((TypeFunction *)fd->type)->isproperty)
+ return resolveProperties(sc, e1);
+ }
+ else if (td && td->onemember &&
+ (fd = td->onemember->isFuncDeclaration()) != NULL)
+ {
+ if (((TypeFunction *)fd->type)->isproperty ||
+ (fd->storage_class2 & STCproperty) ||
+ (td->_scope->stc & STCproperty))
+ {
+ return resolveProperties(sc, e1);
+ }
+ }
+ }
+ }
+ else if (e1->op == TOKdotti)
+ {
+ DotTemplateInstanceExp* dti = (DotTemplateInstanceExp *)e1;
+ if (dti->ti->tempdecl && (td = dti->ti->tempdecl->isTemplateDeclaration()) != NULL)
+ goto Ltd;
+ }
+ else if (e1->op == TOKdottd)
+ {
+ td = ((DotTemplateExp *)e1)->td;
+ goto Ltd;
+ }
+ else if (e1->op == TOKscope)
+ {
+ Dsymbol *s = ((ScopeExp *)e1)->sds;
+ TemplateInstance *ti = s->isTemplateInstance();
+ if (ti && !ti->semanticRun && ti->tempdecl)
+ {
+ if ((td = ti->tempdecl->isTemplateDeclaration()) != NULL)
+ goto Ltd;
+ }
+ }
+ else if (e1->op == TOKtemplate)
+ {
+ td = ((TemplateExp *)e1)->td;
+ Ltd:
+ assert(td);
+ if (td->onemember &&
+ (fd = td->onemember->isFuncDeclaration()) != NULL)
+ {
+ if (((TypeFunction *)fd->type)->isproperty ||
+ (fd->storage_class2 & STCproperty) ||
+ (td->_scope->stc & STCproperty))
+ {
+ return resolveProperties(sc, e1);
+ }
+ }
+ }
+ else if (e1->op == TOKdotvar && e1->type->ty == Tfunction)
+ {
+ DotVarExp *dve = (DotVarExp *)e1;
+ fd = dve->var->isFuncDeclaration();
+ goto Lfd;
+ }
+ else if (e1->op == TOKvar && e1->type->ty == Tfunction &&
+ (sc->intypeof || !((VarExp *)e1)->var->needThis()))
+ {
+ fd = ((VarExp *)e1)->var->isFuncDeclaration();
+ Lfd:
+ assert(fd);
+ if (((TypeFunction *)fd->type)->isproperty)
+ return resolveProperties(sc, e1);
+ }
+ return e1;
+}
+
+/*************************************************************
+ * Given var, we need to get the
+ * right 'this' pointer if var is in an outer class, but our
+ * existing 'this' pointer is in an inner class.
+ * Input:
+ * e1 existing 'this'
+ * ad struct or class we need the correct 'this' for
+ * var the specific member of ad we're accessing
+ */
+
+static Expression *getRightThis(Loc loc, Scope *sc, AggregateDeclaration *ad,
+ Expression *e1, Declaration *var, int flag = 0)
+{
+ //printf("\ngetRightThis(e1 = %s, ad = %s, var = %s)\n", e1->toChars(), ad->toChars(), var->toChars());
+ L1:
+ Type *t = e1->type->toBasetype();
+ //printf("e1->type = %s, var->type = %s\n", e1->type->toChars(), var->type->toChars());
+
+ /* If e1 is not the 'this' pointer for ad
+ */
+ if (ad &&
+ !(t->ty == Tpointer && t->nextOf()->ty == Tstruct &&
+ ((TypeStruct *)t->nextOf())->sym == ad)
+ &&
+ !(t->ty == Tstruct &&
+ ((TypeStruct *)t)->sym == ad)
+ )
+ {
+ ClassDeclaration *cd = ad->isClassDeclaration();
+ ClassDeclaration *tcd = t->isClassHandle();
+
+ /* e1 is the right this if ad is a base class of e1
+ */
+ if (!cd || !tcd ||
+ !(tcd == cd || cd->isBaseOf(tcd, NULL))
+ )
+ {
+ /* Only classes can be inner classes with an 'outer'
+ * member pointing to the enclosing class instance
+ */
+ if (tcd && tcd->isNested())
+ {
+ /* e1 is the 'this' pointer for an inner class: tcd.
+ * Rewrite it as the 'this' pointer for the outer class.
+ */
+
+ e1 = new DotVarExp(loc, e1, tcd->vthis);
+ e1->type = tcd->vthis->type;
+ e1->type = e1->type->addMod(t->mod);
+ // Do not call checkNestedRef()
+ //e1 = expressionSemantic(e1, sc);
+
+ // Skip up over nested functions, and get the enclosing
+ // class type.
+ int n = 0;
+ Dsymbol *s;
+ for (s = tcd->toParent();
+ s && s->isFuncDeclaration();
+ s = s->toParent())
+ {
+ FuncDeclaration *f = s->isFuncDeclaration();
+ if (f->vthis)
+ {
+ //printf("rewriting e1 to %s's this\n", f->toChars());
+ n++;
+ e1 = new VarExp(loc, f->vthis);
+ }
+ else
+ {
+ e1->error("need `this` of type %s to access member %s"
+ " from static function %s",
+ ad->toChars(), var->toChars(), f->toChars());
+ e1 = new ErrorExp();
+ return e1;
+ }
+ }
+ if (s && s->isClassDeclaration())
+ {
+ e1->type = s->isClassDeclaration()->type;
+ e1->type = e1->type->addMod(t->mod);
+ if (n > 1)
+ e1 = expressionSemantic(e1, sc);
+ }
+ else
+ e1 = expressionSemantic(e1, sc);
+ goto L1;
+ }
+
+ /* Can't find a path from e1 to ad
+ */
+ if (flag)
+ return NULL;
+ e1->error("this for %s needs to be type %s not type %s",
+ var->toChars(), ad->toChars(), t->toChars());
+ return new ErrorExp();
+ }
+ }
+ return e1;
+}
+
+/***************************************
+ * Pull out any properties.
+ */
+
+static Expression *resolvePropertiesX(Scope *sc, Expression *e1, Expression *e2 = NULL)
+{
+ //printf("resolvePropertiesX, e1 = %s %s, e2 = %s\n", Token::toChars(e1->op), e1->toChars(), e2 ? e2->toChars() : NULL);
+ Loc loc = e1->loc;
+
+ OverloadSet *os;
+ Dsymbol *s;
+ Objects *tiargs;
+ Type *tthis;
+ if (e1->op == TOKdot)
+ {
+ DotExp *de = (DotExp *)e1;
+ if (de->e2->op == TOKoverloadset)
+ {
+ tiargs = NULL;
+ tthis = de->e1->type;
+ os = ((OverExp *)de->e2)->vars;
+ goto Los;
+ }
+ }
+ else if (e1->op == TOKoverloadset)
+ {
+ tiargs = NULL;
+ tthis = NULL;
+ os = ((OverExp *)e1)->vars;
+ Los:
+ assert(os);
+ FuncDeclaration *fd = NULL;
+ if (e2)
+ {
+ e2 = expressionSemantic(e2, sc);
+ if (e2->op == TOKerror)
+ return new ErrorExp();
+ e2 = resolveProperties(sc, e2);
+
+ Expressions a;
+ a.push(e2);
+
+ for (size_t i = 0; i < os->a.length; i++)
+ {
+ FuncDeclaration *f = resolveFuncCall(loc, sc, os->a[i], tiargs, tthis, &a, 1);
+ if (f)
+ {
+ if (f->errors)
+ return new ErrorExp();
+ fd = f;
+ assert(fd->type->ty == Tfunction);
+ }
+ }
+ if (fd)
+ {
+ Expression *e = new CallExp(loc, e1, e2);
+ return expressionSemantic(e, sc);
+ }
+ }
+ {
+ for (size_t i = 0; i < os->a.length; i++)
+ {
+ FuncDeclaration *f = resolveFuncCall(loc, sc, os->a[i], tiargs, tthis, NULL, 1);
+ if (f)
+ {
+ if (f->errors)
+ return new ErrorExp();
+ fd = f;
+ assert(fd->type->ty == Tfunction);
+ TypeFunction *tf = (TypeFunction *)fd->type;
+ if (!tf->isref && e2)
+ goto Leproplvalue;
+ }
+ }
+ if (fd)
+ {
+ Expression *e = new CallExp(loc, e1);
+ if (e2)
+ e = new AssignExp(loc, e, e2);
+ return expressionSemantic(e, sc);
+ }
+ }
+ if (e2)
+ goto Leprop;
+ }
+ else if (e1->op == TOKdotti)
+ {
+ DotTemplateInstanceExp* dti = (DotTemplateInstanceExp *)e1;
+ if (!dti->findTempDecl(sc))
+ goto Leprop;
+ if (!dti->ti->semanticTiargs(sc))
+ goto Leprop;
+ tiargs = dti->ti->tiargs;
+ tthis = dti->e1->type;
+ if ((os = dti->ti->tempdecl->isOverloadSet()) != NULL)
+ goto Los;
+ if ((s = dti->ti->tempdecl) != NULL)
+ goto Lfd;
+ }
+ else if (e1->op == TOKdottd)
+ {
+ DotTemplateExp *dte = (DotTemplateExp *)e1;
+ s = dte->td;
+ tiargs = NULL;
+ tthis = dte->e1->type;
+ goto Lfd;
+ }
+ else if (e1->op == TOKscope)
+ {
+ s = ((ScopeExp *)e1)->sds;
+ TemplateInstance *ti = s->isTemplateInstance();
+ if (ti && !ti->semanticRun && ti->tempdecl)
+ {
+ //assert(ti->needsTypeInference(sc));
+ if (!ti->semanticTiargs(sc))
+ goto Leprop;
+ tiargs = ti->tiargs;
+ tthis = NULL;
+ if ((os = ti->tempdecl->isOverloadSet()) != NULL)
+ goto Los;
+ if ((s = ti->tempdecl) != NULL)
+ goto Lfd;
+ }
+ }
+ else if (e1->op == TOKtemplate)
+ {
+ s = ((TemplateExp *)e1)->td;
+ tiargs = NULL;
+ tthis = NULL;
+ goto Lfd;
+ }
+ else if (e1->op == TOKdotvar && e1->type && e1->type->toBasetype()->ty == Tfunction)
+ {
+ DotVarExp *dve = (DotVarExp *)e1;
+ s = dve->var->isFuncDeclaration();
+ tiargs = NULL;
+ tthis = dve->e1->type;
+ goto Lfd;
+ }
+ else if (e1->op == TOKvar && e1->type && e1->type->toBasetype()->ty == Tfunction)
+ {
+ s = ((VarExp *)e1)->var->isFuncDeclaration();
+ tiargs = NULL;
+ tthis = NULL;
+ Lfd:
+ assert(s);
+ if (e2)
+ {
+ e2 = expressionSemantic(e2, sc);
+ if (e2->op == TOKerror)
+ return new ErrorExp();
+ e2 = resolveProperties(sc, e2);
+
+ Expressions a;
+ a.push(e2);
+
+ FuncDeclaration *fd = resolveFuncCall(loc, sc, s, tiargs, tthis, &a, 1);
+ if (fd && fd->type)
+ {
+ if (fd->errors)
+ return new ErrorExp();
+ assert(fd->type->ty == Tfunction);
+ Expression *e = new CallExp(loc, e1, e2);
+ return expressionSemantic(e, sc);
+ }
+ }
+ {
+ FuncDeclaration *fd = resolveFuncCall(loc, sc, s, tiargs, tthis, NULL, 1);
+ if (fd && fd->type)
+ {
+ if (fd->errors)
+ return new ErrorExp();
+ assert(fd->type->ty == Tfunction);
+ TypeFunction *tf = (TypeFunction *)fd->type;
+ if (!e2 || tf->isref)
+ {
+ Expression *e = new CallExp(loc, e1);
+ if (e2)
+ e = new AssignExp(loc, e, e2);
+ return expressionSemantic(e, sc);
+ }
+ }
+ }
+ if (FuncDeclaration *fd = s->isFuncDeclaration())
+ {
+ // Keep better diagnostic message for invalid property usage of functions
+ assert(fd->type->ty == Tfunction);
+ Expression *e = new CallExp(loc, e1, e2);
+ return expressionSemantic(e, sc);
+ }
+ if (e2)
+ goto Leprop;
+ }
+ if (e1->op == TOKvar)
+ {
+ VarExp *ve = (VarExp *)e1;
+ VarDeclaration *v = ve->var->isVarDeclaration();
+ if (v && ve->checkPurity(sc, v))
+ return new ErrorExp();
+ }
+ if (e2)
+ return NULL;
+
+ if (e1->type &&
+ e1->op != TOKtype) // function type is not a property
+ {
+ /* Look for e1 being a lazy parameter; rewrite as delegate call
+ */
+ if (e1->op == TOKvar)
+ {
+ VarExp *ve = (VarExp *)e1;
+
+ if (ve->var->storage_class & STClazy)
+ {
+ Expression *e = new CallExp(loc, e1);
+ return expressionSemantic(e, sc);
+ }
+ }
+ else if (e1->op == TOKdotvar)
+ {
+ // Check for reading overlapped pointer field in @safe code.
+ if (checkUnsafeAccess(sc, e1, true, true))
+ return new ErrorExp();
+ }
+ else if (e1->op == TOKdot)
+ {
+ e1->error("expression has no value");
+ return new ErrorExp();
+ }
+ else if (e1->op == TOKcall)
+ {
+ CallExp *ce = (CallExp *)e1;
+ // Check for reading overlapped pointer field in @safe code.
+ if (checkUnsafeAccess(sc, ce->e1, true, true))
+ return new ErrorExp();
+ }
+ }
+
+ if (!e1->type)
+ {
+ error(loc, "cannot resolve type for %s", e1->toChars());
+ e1 = new ErrorExp();
+ }
+ return e1;
+
+Leprop:
+ error(loc, "not a property %s", e1->toChars());
+ return new ErrorExp();
+
+Leproplvalue:
+ error(loc, "%s is not an lvalue", e1->toChars());
+ return new ErrorExp();
+}
+
+Expression *resolveProperties(Scope *sc, Expression *e)
+{
+ //printf("resolveProperties(%s)\n", e->toChars());
+
+ e = resolvePropertiesX(sc, e);
+ if (e->checkRightThis(sc))
+ return new ErrorExp();
+ return e;
+}
+
+/****************************************
+ * The common type is determined by applying ?: to each pair.
+ * Output:
+ * exps[] properties resolved, implicitly cast to common type, rewritten in place
+ * *pt if pt is not NULL, set to the common type
+ * Returns:
+ * true a semantic error was detected
+ */
+
+static bool arrayExpressionToCommonType(Scope *sc, Expressions *exps, Type **pt)
+{
+ /* Still have a problem with:
+ * ubyte[][] = [ cast(ubyte[])"hello", [1]];
+ * which works if the array literal is initialized top down with the ubyte[][]
+ * type, but fails with this function doing bottom up typing.
+ */
+ //printf("arrayExpressionToCommonType()\n");
+ IntegerExp integerexp(0);
+ CondExp condexp(Loc(), &integerexp, NULL, NULL);
+
+ Type *t0 = NULL;
+ Expression *e0 = NULL; // dead-store to prevent spurious warning
+ size_t j0 = ~0; // dead-store to prevent spurious warning
+ bool foundType = false;
+
+ for (size_t i = 0; i < exps->length; i++)
+ {
+ Expression *e = (*exps)[i];
+ if (!e)
+ continue;
+
+ e = resolveProperties(sc, e);
+ if (!e->type)
+ {
+ e->error("%s has no value", e->toChars());
+ t0 = Type::terror;
+ continue;
+ }
+ if (e->op == TOKtype)
+ {
+ foundType = true; // do not break immediately, there might be more errors
+ e->checkValue(); // report an error "type T has no value"
+ t0 = Type::terror;
+ continue;
+ }
+ if (e->type->ty == Tvoid)
+ {
+ // void expressions do not concur to the determination of the common
+ // type.
+ continue;
+ }
+ if (checkNonAssignmentArrayOp(e))
+ {
+ t0 = Type::terror;
+ continue;
+ }
+
+ e = doCopyOrMove(sc, e);
+
+ if (!foundType && t0 && !t0->equals(e->type))
+ {
+ /* This applies ?: to merge the types. It's backwards;
+ * ?: should call this function to merge types.
+ */
+ condexp.type = NULL;
+ condexp.e1 = e0;
+ condexp.e2 = e;
+ condexp.loc = e->loc;
+ Expression *ex = expressionSemantic(&condexp, sc);
+ if (ex->op == TOKerror)
+ e = ex;
+ else
+ {
+ (*exps)[j0] = condexp.e1;
+ e = condexp.e2;
+ }
+ }
+ j0 = i;
+ e0 = e;
+ t0 = e->type;
+ if (e->op != TOKerror)
+ (*exps)[i] = e;
+ }
+
+ if (!t0)
+ t0 = Type::tvoid; // [] is typed as void[]
+ else if (t0->ty != Terror)
+ {
+ for (size_t i = 0; i < exps->length; i++)
+ {
+ Expression *e = (*exps)[i];
+ if (!e)
+ continue;
+
+ e = e->implicitCastTo(sc, t0);
+ //assert(e->op != TOKerror);
+ if (e->op == TOKerror)
+ {
+ /* Bugzilla 13024: a workaround for the bug in typeMerge -
+ * it should paint e1 and e2 by deduced common type,
+ * but doesn't in this particular case.
+ */
+ t0 = Type::terror;
+ break;
+ }
+ (*exps)[i] = e;
+ }
+ }
+ if (pt)
+ *pt = t0;
+
+ return (t0 == Type::terror);
+}
+
+static Expression *opAssignToOp(Loc loc, TOK op, Expression *e1, Expression *e2)
+{ Expression *e;
+
+ switch (op)
+ {
+ case TOKaddass: e = new AddExp(loc, e1, e2); break;
+ case TOKminass: e = new MinExp(loc, e1, e2); break;
+ case TOKmulass: e = new MulExp(loc, e1, e2); break;
+ case TOKdivass: e = new DivExp(loc, e1, e2); break;
+ case TOKmodass: e = new ModExp(loc, e1, e2); break;
+ case TOKandass: e = new AndExp(loc, e1, e2); break;
+ case TOKorass: e = new OrExp (loc, e1, e2); break;
+ case TOKxorass: e = new XorExp(loc, e1, e2); break;
+ case TOKshlass: e = new ShlExp(loc, e1, e2); break;
+ case TOKshrass: e = new ShrExp(loc, e1, e2); break;
+ case TOKushrass: e = new UshrExp(loc, e1, e2); break;
+ default: assert(0);
+ }
+ return e;
+}
+
+/*********************
+ * Rewrite:
+ * array.length op= e2
+ * as:
+ * array.length = array.length op e2
+ * or:
+ * auto tmp = &array;
+ * (*tmp).length = (*tmp).length op e2
+ */
+
+static Expression *rewriteOpAssign(BinExp *exp)
+{
+ Expression *e;
+
+ assert(exp->e1->op == TOKarraylength);
+ ArrayLengthExp *ale = (ArrayLengthExp *)exp->e1;
+ if (ale->e1->op == TOKvar)
+ {
+ e = opAssignToOp(exp->loc, exp->op, ale, exp->e2);
+ e = new AssignExp(exp->loc, ale->syntaxCopy(), e);
+ }
+ else
+ {
+ /* auto tmp = &array;
+ * (*tmp).length = (*tmp).length op e2
+ */
+ VarDeclaration *tmp = copyToTemp(0, "__arraylength", new AddrExp(ale->loc, ale->e1));
+
+ Expression *e1 = new ArrayLengthExp(ale->loc, new PtrExp(ale->loc, new VarExp(ale->loc, tmp)));
+ Expression *elvalue = e1->syntaxCopy();
+ e = opAssignToOp(exp->loc, exp->op, e1, exp->e2);
+ e = new AssignExp(exp->loc, elvalue, e);
+ e = new CommaExp(exp->loc, new DeclarationExp(ale->loc, tmp), e);
+ }
+ return e;
+}
/****************************************
* Preprocess arguments to function.
@@ -76,39 +1302,728 @@ Expression *resolvePropertiesX(Scope *sc, Expression *e1, Expression *e2 = NULL)
* true a semantic error occurred
*/
-static bool preFunctionParameters(Scope *sc, Expressions *exps)
-{
- bool err = false;
- if (exps)
+static bool preFunctionParameters(Scope *sc, Expressions *exps)
+{
+ bool err = false;
+ if (exps)
+ {
+ expandTuples(exps);
+
+ for (size_t i = 0; i < exps->length; i++)
+ {
+ Expression *arg = (*exps)[i];
+
+ arg = resolveProperties(sc, arg);
+ if (arg->op == TOKtype)
+ {
+ arg->error("cannot pass type %s as a function argument", arg->toChars());
+ arg = new ErrorExp();
+ err = true;
+ }
+ else if (arg->type->toBasetype()->ty == Tfunction)
+ {
+ arg->error("cannot pass type %s as a function argument", arg->toChars());
+ arg = new ErrorExp();
+ err = true;
+ }
+ else if (checkNonAssignmentArrayOp(arg))
+ {
+ arg = new ErrorExp();
+ err = true;
+ }
+ (*exps)[i] = arg;
+ }
+ }
+ return err;
+}
+
+/********************************************
+ * Issue an error if default construction is disabled for type t.
+ * Default construction is required for arrays and 'out' parameters.
+ * Returns:
+ * true an error was issued
+ */
+static bool checkDefCtor(Loc loc, Type *t)
+{
+ t = t->baseElemOf();
+ if (t->ty == Tstruct)
+ {
+ StructDeclaration *sd = ((TypeStruct *)t)->sym;
+ if (sd->noDefaultCtor)
+ {
+ sd->error(loc, "default construction is disabled");
+ return true;
+ }
+ }
+ return false;
+}
+
+/****************************************
+ * Now that we know the exact type of the function we're calling,
+ * the arguments[] need to be adjusted:
+ * 1. implicitly convert argument to the corresponding parameter type
+ * 2. add default arguments for any missing arguments
+ * 3. do default promotions on arguments corresponding to ...
+ * 4. add hidden _arguments[] argument
+ * 5. call copy constructor for struct value arguments
+ * Input:
+ * tf type of the function
+ * fd the function being called, NULL if called indirectly
+ * Output:
+ * *prettype return type of function
+ * *peprefix expression to execute before arguments[] are evaluated, NULL if none
+ * Returns:
+ * true errors happened
+ */
+
+static bool functionParameters(Loc loc, Scope *sc, TypeFunction *tf,
+ Type *tthis, Expressions *arguments, FuncDeclaration *fd, Type **prettype, Expression **peprefix)
+{
+ //printf("functionParameters()\n");
+ assert(arguments);
+ assert(fd || tf->next);
+ size_t nargs = arguments ? arguments->length : 0;
+ size_t nparams = tf->parameterList.length();
+ unsigned olderrors = global.errors;
+ bool err = false;
+ *prettype = Type::terror;
+ Expression *eprefix = NULL;
+ *peprefix = NULL;
+
+ if (nargs > nparams && tf->parameterList.varargs == VARARGnone)
+ {
+ error(loc, "expected %llu arguments, not %llu for non-variadic function type %s", (ulonglong)nparams, (ulonglong)nargs, tf->toChars());
+ return true;
+ }
+
+ // If inferring return type, and semantic3() needs to be run if not already run
+ if (!tf->next && fd->inferRetType)
+ {
+ fd->functionSemantic();
+ }
+ else if (fd && fd->parent)
+ {
+ TemplateInstance *ti = fd->parent->isTemplateInstance();
+ if (ti && ti->tempdecl)
+ {
+ fd->functionSemantic3();
+ }
+ }
+ bool isCtorCall = fd && fd->needThis() && fd->isCtorDeclaration();
+
+ size_t n = (nargs > nparams) ? nargs : nparams; // n = max(nargs, nparams)
+
+ /* If the function return type has wildcards in it, we'll need to figure out the actual type
+ * based on the actual argument types.
+ */
+ MOD wildmatch = 0;
+ if (tthis && tf->isWild() && !isCtorCall)
+ {
+ Type *t = tthis;
+ if (t->isImmutable())
+ wildmatch = MODimmutable;
+ else if (t->isWildConst())
+ wildmatch = MODwildconst;
+ else if (t->isWild())
+ wildmatch = MODwild;
+ else if (t->isConst())
+ wildmatch = MODconst;
+ else
+ wildmatch = MODmutable;
+ }
+
+ int done = 0;
+ for (size_t i = 0; i < n; i++)
+ {
+ Expression *arg;
+
+ if (i < nargs)
+ arg = (*arguments)[i];
+ else
+ arg = NULL;
+
+ if (i < nparams)
+ {
+ Parameter *p = tf->parameterList[i];
+
+ if (!arg)
+ {
+ if (!p->defaultArg)
+ {
+ if (tf->parameterList.varargs == VARARGtypesafe && i + 1 == nparams)
+ goto L2;
+ error(loc, "expected %llu function arguments, not %llu", (ulonglong)nparams, (ulonglong)nargs);
+ return true;
+ }
+ arg = p->defaultArg;
+ arg = inlineCopy(arg, sc);
+ // __FILE__, __LINE__, __MODULE__, __FUNCTION__, and __PRETTY_FUNCTION__
+ arg = arg->resolveLoc(loc, sc);
+ arguments->push(arg);
+ nargs++;
+ }
+
+ if (tf->parameterList.varargs == VARARGtypesafe && i + 1 == nparams)
+ {
+ //printf("\t\tvarargs == 2, p->type = '%s'\n", p->type->toChars());
+ {
+ MATCH m;
+ if ((m = arg->implicitConvTo(p->type)) > MATCHnomatch)
+ {
+ if (p->type->nextOf() && arg->implicitConvTo(p->type->nextOf()) >= m)
+ goto L2;
+ else if (nargs != nparams)
+ { error(loc, "expected %llu function arguments, not %llu", (ulonglong)nparams, (ulonglong)nargs);
+ return true;
+ }
+ goto L1;
+ }
+ }
+ L2:
+ Type *tb = p->type->toBasetype();
+ Type *tret = p->isLazyArray();
+ switch (tb->ty)
+ {
+ case Tsarray:
+ case Tarray:
+ {
+ /* Create a static array variable v of type arg->type:
+ * T[dim] __arrayArg = [ arguments[i], ..., arguments[nargs-1] ];
+ *
+ * The array literal in the initializer of the hidden variable
+ * is now optimized. See Bugzilla 2356.
+ */
+ Type *tbn = ((TypeArray *)tb)->next;
+
+ Expressions *elements = new Expressions();
+ elements->setDim(nargs - i);
+ for (size_t u = 0; u < elements->length; u++)
+ {
+ Expression *a = (*arguments)[i + u];
+ if (tret && a->implicitConvTo(tret))
+ {
+ a = a->implicitCastTo(sc, tret);
+ a = a->optimize(WANTvalue);
+ a = toDelegate(a, a->type, sc);
+ }
+ else
+ a = a->implicitCastTo(sc, tbn);
+ (*elements)[u] = a;
+ }
+ // Bugzilla 14395: Convert to a static array literal, or its slice.
+ arg = new ArrayLiteralExp(loc, tbn->sarrayOf(nargs - i), elements);
+ if (tb->ty == Tarray)
+ {
+ arg = new SliceExp(loc, arg, NULL, NULL);
+ arg->type = p->type;
+ }
+ break;
+ }
+ case Tclass:
+ {
+ /* Set arg to be:
+ * new Tclass(arg0, arg1, ..., argn)
+ */
+ Expressions *args = new Expressions();
+ args->setDim(nargs - i);
+ for (size_t u = i; u < nargs; u++)
+ (*args)[u - i] = (*arguments)[u];
+ arg = new NewExp(loc, NULL, NULL, p->type, args);
+ break;
+ }
+ default:
+ if (!arg)
+ {
+ error(loc, "not enough arguments");
+ return true;
+ }
+ break;
+ }
+ arg = expressionSemantic(arg, sc);
+ //printf("\targ = '%s'\n", arg->toChars());
+ arguments->setDim(i + 1);
+ (*arguments)[i] = arg;
+ nargs = i + 1;
+ done = 1;
+ }
+
+ L1:
+ if (!(p->storageClass & STClazy && p->type->ty == Tvoid))
+ {
+ bool isRef = (p->storageClass & (STCref | STCout)) != 0;
+ if (unsigned char wm = arg->type->deduceWild(p->type, isRef))
+ {
+ if (wildmatch)
+ wildmatch = MODmerge(wildmatch, wm);
+ else
+ wildmatch = wm;
+ //printf("[%d] p = %s, a = %s, wm = %d, wildmatch = %d\n", i, p->type->toChars(), arg->type->toChars(), wm, wildmatch);
+ }
+ }
+ }
+ if (done)
+ break;
+ }
+ if ((wildmatch == MODmutable || wildmatch == MODimmutable) &&
+ tf->next->hasWild() &&
+ (tf->isref || !tf->next->implicitConvTo(tf->next->immutableOf())))
{
- expandTuples(exps);
+ if (fd)
+ {
+ /* If the called function may return the reference to
+ * outer inout data, it should be rejected.
+ *
+ * void foo(ref inout(int) x) {
+ * ref inout(int) bar(inout(int)) { return x; }
+ * struct S { ref inout(int) bar() inout { return x; } }
+ * bar(int.init) = 1; // bad!
+ * S().bar() = 1; // bad!
+ * }
+ */
+ Dsymbol *s = NULL;
+ if (fd->isThis() || fd->isNested())
+ s = fd->toParent2();
+ for (; s; s = s->toParent2())
+ {
+ if (AggregateDeclaration *ad = s->isAggregateDeclaration())
+ {
+ if (ad->isNested())
+ continue;
+ break;
+ }
+ if (FuncDeclaration *ff = s->isFuncDeclaration())
+ {
+ if (((TypeFunction *)ff->type)->iswild)
+ goto Linouterr;
- for (size_t i = 0; i < exps->length; i++)
+ if (ff->isNested() || ff->isThis())
+ continue;
+ }
+ break;
+ }
+ }
+ else if (tf->isWild())
{
- Expression *arg = (*exps)[i];
+ Linouterr:
+ const char *s = wildmatch == MODmutable ? "mutable" : MODtoChars(wildmatch);
+ error(loc, "modify inout to %s is not allowed inside inout function", s);
+ return true;
+ }
+ }
- arg = resolveProperties(sc, arg);
- if (arg->op == TOKtype)
+ assert(nargs >= nparams);
+ for (size_t i = 0; i < nargs; i++)
+ {
+ Expression *arg = (*arguments)[i];
+ assert(arg);
+ if (i < nparams)
+ {
+ Parameter *p = tf->parameterList[i];
+
+ if (!(p->storageClass & STClazy && p->type->ty == Tvoid))
{
- arg->error("cannot pass type %s as a function argument", arg->toChars());
- arg = new ErrorExp();
+ Type *tprm = p->type;
+ if (p->type->hasWild())
+ tprm = p->type->substWildTo(wildmatch);
+ if (!tprm->equals(arg->type))
+ {
+ //printf("arg->type = %s, p->type = %s\n", arg->type->toChars(), p->type->toChars());
+ arg = arg->implicitCastTo(sc, tprm);
+ arg = arg->optimize(WANTvalue, (p->storageClass & (STCref | STCout)) != 0);
+ }
+ }
+ if (p->storageClass & STCref)
+ {
+ arg = arg->toLvalue(sc, arg);
+
+ // Look for mutable misaligned pointer, etc., in @safe mode
+ err |= checkUnsafeAccess(sc, arg, false, true);
+ }
+ else if (p->storageClass & STCout)
+ {
+ Type *t = arg->type;
+ if (!t->isMutable() || !t->isAssignable()) // check blit assignable
+ {
+ arg->error("cannot modify struct %s with immutable members", arg->toChars());
+ err = true;
+ }
+ else
+ {
+ // Look for misaligned pointer, etc., in @safe mode
+ err |= checkUnsafeAccess(sc, arg, false, true);
+ err |= checkDefCtor(arg->loc, t); // t must be default constructible
+ }
+ arg = arg->toLvalue(sc, arg);
+ }
+ else if (p->storageClass & STClazy)
+ {
+ // Convert lazy argument to a delegate
+ if (p->type->ty == Tvoid)
+ arg = toDelegate(arg, p->type, sc);
+ else
+ arg = toDelegate(arg, arg->type, sc);
+ }
+
+ //printf("arg: %s\n", arg->toChars());
+ //printf("type: %s\n", arg->type->toChars());
+ if (tf->parameterEscapes(p))
+ {
+ /* Argument value can escape from the called function.
+ * Check arg to see if it matters.
+ */
+ if (global.params.vsafe)
+ err |= checkParamArgumentEscape(sc, fd, p->ident, arg, false);
+ }
+ else
+ {
+ /* Argument value cannot escape from the called function.
+ */
+ Expression *a = arg;
+ if (a->op == TOKcast)
+ a = ((CastExp *)a)->e1;
+
+ if (a->op == TOKfunction)
+ {
+ /* Function literals can only appear once, so if this
+ * appearance was scoped, there cannot be any others.
+ */
+ FuncExp *fe = (FuncExp *)a;
+ fe->fd->tookAddressOf = 0;
+ }
+ else if (a->op == TOKdelegate)
+ {
+ /* For passing a delegate to a scoped parameter,
+ * this doesn't count as taking the address of it.
+ * We only worry about 'escaping' references to the function.
+ */
+ DelegateExp *de = (DelegateExp *)a;
+ if (de->e1->op == TOKvar)
+ { VarExp *ve = (VarExp *)de->e1;
+ FuncDeclaration *f = ve->var->isFuncDeclaration();
+ if (f)
+ { f->tookAddressOf--;
+ //printf("tookAddressOf = %d\n", f->tookAddressOf);
+ }
+ }
+ }
+ }
+ arg = arg->optimize(WANTvalue, (p->storageClass & (STCref | STCout)) != 0);
+ }
+ else
+ {
+ // These will be the trailing ... arguments
+
+ // If not D linkage, do promotions
+ if (tf->linkage != LINKd)
+ {
+ // Promote bytes, words, etc., to ints
+ arg = integralPromotions(arg, sc);
+
+ // Promote floats to doubles
+ switch (arg->type->ty)
+ {
+ case Tfloat32:
+ arg = arg->castTo(sc, Type::tfloat64);
+ break;
+
+ case Timaginary32:
+ arg = arg->castTo(sc, Type::timaginary64);
+ break;
+ }
+
+ if (tf->parameterList.varargs == VARARGvariadic)
+ {
+ const char *p = tf->linkage == LINKc ? "extern(C)" : "extern(C++)";
+ if (arg->type->ty == Tarray)
+ {
+ arg->error("cannot pass dynamic arrays to %s vararg functions", p);
+ err = true;
+ }
+ if (arg->type->ty == Tsarray)
+ {
+ arg->error("cannot pass static arrays to %s vararg functions", p);
+ err = true;
+ }
+ }
+ }
+
+ // Do not allow types that need destructors
+ if (arg->type->needsDestruction())
+ {
+ arg->error("cannot pass types that need destruction as variadic arguments");
err = true;
}
- else if (arg->type->toBasetype()->ty == Tfunction)
+
+ // Convert static arrays to dynamic arrays
+ // BUG: I don't think this is right for D2
+ Type *tb = arg->type->toBasetype();
+ if (tb->ty == Tsarray)
{
- arg->error("cannot pass type %s as a function argument", arg->toChars());
- arg = new ErrorExp();
+ TypeSArray *ts = (TypeSArray *)tb;
+ Type *ta = ts->next->arrayOf();
+ if (ts->size(arg->loc) == 0)
+ arg = new NullExp(arg->loc, ta);
+ else
+ arg = arg->castTo(sc, ta);
+ }
+ if (tb->ty == Tstruct)
+ {
+ //arg = callCpCtor(sc, arg);
+ }
+
+ // Give error for overloaded function addresses
+ if (arg->op == TOKsymoff)
+ { SymOffExp *se = (SymOffExp *)arg;
+ if (se->hasOverloads &&
+ !se->var->isFuncDeclaration()->isUnique())
+ { arg->error("function %s is overloaded", arg->toChars());
+ err = true;
+ }
+ }
+ if (arg->checkValue())
err = true;
+ arg = arg->optimize(WANTvalue);
+ }
+ (*arguments)[i] = arg;
+ }
+
+ /* If calling C scanf(), printf(), or any variants, check the format string against the arguments
+ */
+ const bool isVa_list = tf->parameterList.varargs == VARARGnone;
+ if (fd && (fd->flags & FUNCFLAGprintf))
+ {
+ if (StringExp *se = (*arguments)[nparams - 1 - isVa_list]->isStringExp())
+ {
+ Expressions argslice;
+ argslice.reserve(nargs - nparams);
+ for (size_t i = nparams; i < nargs; i++)
+ argslice.push((*arguments)[i]);
+ checkPrintfFormat(se->loc, se->toPtr(), argslice, isVa_list);
+ }
+ }
+ else if (fd && (fd->flags & FUNCFLAGscanf))
+ {
+ if (StringExp *se = (*arguments)[nparams - 1 - isVa_list]->isStringExp())
+ {
+ Expressions argslice;
+ argslice.reserve(nargs - nparams);
+ for (size_t i = nparams; i < nargs; i++)
+ argslice.push((*arguments)[i]);
+ checkPrintfFormat(se->loc, se->toPtr(), argslice, isVa_list);
+ }
+ }
+
+ /* Remaining problems:
+ * 1. order of evaluation - some function push L-to-R, others R-to-L. Until we resolve what array assignment does (which is
+ * implemented by calling a function) we'll defer this for now.
+ * 2. value structs (or static arrays of them) that need to be copy constructed
+ * 3. value structs (or static arrays of them) that have destructors, and subsequent arguments that may throw before the
+ * function gets called (functions normally destroy their parameters)
+ * 2 and 3 are handled by doing the argument construction in 'eprefix' so that if a later argument throws, they are cleaned
+ * up properly. Pushing arguments on the stack then cannot fail.
+ */
+ if (1)
+ {
+ /* TODO: tackle problem 1)
+ */
+ const bool leftToRight = true; // TODO: something like !fd.isArrayOp
+ if (!leftToRight)
+ assert(nargs == nparams); // no variadics for RTL order, as they would probably be evaluated LTR and so add complexity
+
+ const ptrdiff_t start = (leftToRight ? 0 : (ptrdiff_t)nargs - 1);
+ const ptrdiff_t end = (leftToRight ? (ptrdiff_t)nargs : -1);
+ const ptrdiff_t step = (leftToRight ? 1 : -1);
+
+ /* Compute indices of last throwing argument and first arg needing destruction.
+ * Used to not set up destructors unless an arg needs destruction on a throw
+ * in a later argument.
+ */
+ ptrdiff_t lastthrow = -1;
+ ptrdiff_t firstdtor = -1;
+ for (ptrdiff_t i = start; i != end; i += step)
+ {
+ Expression *arg = (*arguments)[i];
+ if (canThrow(arg, sc->func, false))
+ lastthrow = i;
+ if (firstdtor == -1 && arg->type->needsDestruction())
+ {
+ Parameter *p = (i >= (ptrdiff_t)nparams ? NULL : tf->parameterList[i]);
+ if (!(p && (p->storageClass & (STClazy | STCref | STCout))))
+ firstdtor = i;
}
- else if (checkNonAssignmentArrayOp(arg))
+ }
+
+ /* Does problem 3) apply to this call?
+ */
+ const bool needsPrefix = (firstdtor >= 0 && lastthrow >= 0
+ && (lastthrow - firstdtor) * step > 0);
+
+ /* If so, initialize 'eprefix' by declaring the gate
+ */
+ VarDeclaration *gate = NULL;
+ if (needsPrefix)
+ {
+ // eprefix => bool __gate [= false]
+ Identifier *idtmp = Identifier::generateId("__gate");
+ gate = new VarDeclaration(loc, Type::tbool, idtmp, NULL);
+ gate->storage_class |= STCtemp | STCctfe | STCvolatile;
+ dsymbolSemantic(gate, sc);
+
+ Expression *ae = new DeclarationExp(loc, gate);
+ eprefix = expressionSemantic(ae, sc);
+ }
+
+ for (ptrdiff_t i = start; i != end; i += step)
+ {
+ Expression *arg = (*arguments)[i];
+
+ Parameter *parameter = (i >= (ptrdiff_t)nparams ? NULL : tf->parameterList[i]);
+ const bool isRef = (parameter && (parameter->storageClass & (STCref | STCout)));
+ const bool isLazy = (parameter && (parameter->storageClass & STClazy));
+
+ /* Skip lazy parameters
+ */
+ if (isLazy)
+ continue;
+
+ /* Do we have a gate? Then we have a prefix and we're not yet past the last throwing arg.
+ * Declare a temporary variable for this arg and append that declaration to 'eprefix',
+ * which will implicitly take care of potential problem 2) for this arg.
+ * 'eprefix' will therefore finally contain all args up to and including the last
+ * potentially throwing arg, excluding all lazy parameters.
+ */
+ if (gate)
{
- arg = new ErrorExp();
+ const bool needsDtor = (!isRef && arg->type->needsDestruction() && i != lastthrow);
+
+ /* Declare temporary 'auto __pfx = arg' (needsDtor) or 'auto __pfy = arg' (!needsDtor)
+ */
+ VarDeclaration *tmp = copyToTemp(0,
+ needsDtor ? "__pfx" : "__pfy",
+ !isRef ? arg : arg->addressOf());
+ dsymbolSemantic(tmp, sc);
+
+ /* Modify the destructor so it only runs if gate==false, i.e.,
+ * only if there was a throw while constructing the args
+ */
+ if (!needsDtor)
+ {
+ if (tmp->edtor)
+ {
+ assert(i == lastthrow);
+ tmp->edtor = NULL;
+ }
+ }
+ else
+ {
+ // edtor => (__gate || edtor)
+ assert(tmp->edtor);
+ Expression *e = tmp->edtor;
+ e = new LogicalExp(e->loc, TOKoror, new VarExp(e->loc, gate), e);
+ tmp->edtor = expressionSemantic(e, sc);
+ //printf("edtor: %s\n", tmp->edtor->toChars());
+ }
+
+ // eprefix => (eprefix, auto __pfx/y = arg)
+ DeclarationExp *ae = new DeclarationExp(loc, tmp);
+ eprefix = Expression::combine(eprefix, expressionSemantic(ae, sc));
+
+ // arg => __pfx/y
+ arg = new VarExp(loc, tmp);
+ arg = expressionSemantic(arg, sc);
+ if (isRef)
+ {
+ arg = new PtrExp(loc, arg);
+ arg = expressionSemantic(arg, sc);
+ }
+
+ /* Last throwing arg? Then finalize eprefix => (eprefix, gate = true),
+ * i.e., disable the dtors right after constructing the last throwing arg.
+ * From now on, the callee will take care of destructing the args because
+ * the args are implicitly moved into function parameters.
+ *
+ * Set gate to null to let the next iterations know they don't need to
+ * append to eprefix anymore.
+ */
+ if (i == lastthrow)
+ {
+ Expression *e = new AssignExp(gate->loc, new VarExp(gate->loc, gate), new IntegerExp(gate->loc, 1, Type::tbool));
+ eprefix = Expression::combine(eprefix, expressionSemantic(e, sc));
+ gate = NULL;
+ }
+ }
+ else
+ {
+ /* No gate, no prefix to append to.
+ * Handle problem 2) by calling the copy constructor for value structs
+ * (or static arrays of them) if appropriate.
+ */
+ Type *tv = arg->type->baseElemOf();
+ if (!isRef && tv->ty == Tstruct)
+ arg = doCopyOrMove(sc, arg);
+ }
+
+ (*arguments)[i] = arg;
+ }
+ }
+ //if (eprefix) printf("eprefix: %s\n", eprefix->toChars());
+
+ // If D linkage and variadic, add _arguments[] as first argument
+ if (tf->isDstyleVariadic())
+ {
+ assert(arguments->length >= nparams);
+
+ Parameters *args = new Parameters;
+ args->setDim(arguments->length - nparams);
+ for (size_t i = 0; i < arguments->length - nparams; i++)
+ {
+ Parameter *arg = new Parameter(STCin, (*arguments)[nparams + i]->type, NULL, NULL, NULL);
+ (*args)[i] = arg;
+ }
+
+ TypeTuple *tup = new TypeTuple(args);
+ Expression *e = new TypeidExp(loc, tup);
+ e = expressionSemantic(e, sc);
+ arguments->insert(0, e);
+ }
+
+ Type *tret = tf->next;
+ if (isCtorCall)
+ {
+ //printf("[%s] fd = %s %s, %d %d %d\n", loc.toChars(), fd->toChars(), fd->type->toChars(),
+ // wildmatch, tf->isWild(), fd->isolateReturn());
+ if (!tthis)
+ {
+ assert(sc->intypeof || global.errors);
+ tthis = fd->isThis()->type->addMod(fd->type->mod);
+ }
+ if (tf->isWild() && !fd->isolateReturn())
+ {
+ if (wildmatch)
+ tret = tret->substWildTo(wildmatch);
+ int offset;
+ if (!tret->implicitConvTo(tthis) &&
+ !(MODimplicitConv(tret->mod, tthis->mod) && tret->isBaseOf(tthis, &offset) && offset == 0))
+ {
+ const char* s1 = tret ->isNaked() ? " mutable" : tret ->modToChars();
+ const char* s2 = tthis->isNaked() ? " mutable" : tthis->modToChars();
+ ::error(loc, "inout constructor %s creates%s object, not%s",
+ fd->toPrettyChars(), s1, s2);
err = true;
}
- (*exps)[i] = arg;
}
+ tret = tthis;
}
- return err;
+ else if (wildmatch && tret)
+ {
+ /* Adjust function return type based on wildmatch
+ */
+ //printf("wildmatch = x%x, tret = %s\n", wildmatch, tret->toChars());
+ tret = tret->substWildTo(wildmatch);
+ }
+ *prettype = tret;
+ *peprefix = eprefix;
+ return (err || olderrors != global.errors);
}
/**
@@ -134,6 +2049,8 @@ Package *resolveIsPackage(Dsymbol *sym)
}
pkg = imp->pkg;
}
+ else if (Module *mod = sym->isModule())
+ pkg = mod->isPackageFile ? mod->pkg : sym->isPackage();
else
pkg = sym->isPackage();
if (pkg)
@@ -141,6 +2058,25 @@ Package *resolveIsPackage(Dsymbol *sym)
return pkg;
}
+static Module *loadStdMath()
+{
+ static Import *impStdMath = NULL;
+ if (!impStdMath)
+ {
+ Identifiers *a = new Identifiers();
+ a->push(Id::std);
+ Import *s = new Import(Loc(), a, Id::math, NULL, false);
+ s->load(NULL);
+ if (s->mod)
+ {
+ s->mod->importAll(NULL);
+ dsymbolSemantic(s->mod, NULL);
+ }
+ impStdMath = s;
+ }
+ return impStdMath->mod;
+}
+
class ExpressionSemanticVisitor : public Visitor
{
public:
@@ -1938,7 +3874,7 @@ public:
void visit(HaltExp *e)
{
- e->type = Type::tvoid;
+ e->type = Type::tnoreturn;
result = e;
}
@@ -1959,7 +3895,9 @@ public:
Type *tded = NULL;
if (e->tok2 == TOKpackage || e->tok2 == TOKmodule) // These is() expressions are special because they can work on modules, not just types.
{
+ const unsigned oldErrors = global.startGagging();
Dsymbol *sym = e->targ->toDsymbol(sc);
+ global.endGagging(oldErrors);
if (sym == NULL)
goto Lno;
Package *p = resolveIsPackage(sym);
@@ -2292,7 +4230,7 @@ public:
if (exp->e1->op == TOKarraylength)
{
// arr.length op= e2;
- e = ArrayLengthExp::rewriteOpAssign(exp);
+ e = rewriteOpAssign(exp);
e = expressionSemantic(e, sc);
result = e;
return;
@@ -2382,27 +4320,39 @@ public:
result = ((BinExp *)e)->reorderSettingAAElem(sc);
}
- void visit(CompileExp *exp)
+private:
+ Expression *compileIt(CompileExp *exp)
{
- StringExp *se = semanticString(sc, exp->e1, "argument to mixin");
- if (!se)
- return setError();
- se = se->toUTF8(sc);
+ OutBuffer buf;
+ if (expressionsToString(buf, sc, exp->exps))
+ return NULL;
+
unsigned errors = global.errors;
- Parser p(exp->loc, sc->_module, (utf8_t *)se->string, se->len, 0);
+ const size_t len = buf.length();
+ const char *str = buf.extractChars();
+ Parser p(exp->loc, sc->_module, (const utf8_t *)str, len, false);
p.nextToken();
//printf("p.loc.linnum = %d\n", p.loc.linnum);
+
Expression *e = p.parseExpression();
- if (p.errors)
- {
- assert(global.errors != errors); // should have caught all these cases
- return setError();
- }
+ if (global.errors != errors)
+ return NULL;
+
if (p.token.value != TOKeof)
{
- exp->error("incomplete mixin expression (%s)", se->toChars());
- return setError();
+ exp->error("incomplete mixin expression (%s)", str);
+ return NULL;
}
+ return e;
+ }
+
+public:
+ void visit(CompileExp *exp)
+ {
+ //printf("CompileExp::semantic('%s')\n", exp->toChars());
+ Expression *e = compileIt(exp);
+ if (!e)
+ return setError();
result = expressionSemantic(e, sc);
}
@@ -2508,6 +4458,8 @@ public:
if (exp->e1->isBool(false))
{
+ /* This is an `assert(0)` which means halt program execution
+ */
FuncDeclaration *fd = sc->parent->isFuncDeclaration();
if (fd)
fd->hasReturnExp |= 4;
@@ -2525,8 +4477,10 @@ public:
result = e;
return;
}
+ exp->type = Type::tnoreturn;
}
- exp->type = Type::tvoid;
+ else
+ exp->type = Type::tvoid;
result = exp;
}
@@ -3484,7 +5438,8 @@ public:
return setError();
}
- if (!tf->callMatch(NULL, exp->arguments))
+ const char *failMessage = NULL;
+ if (!tf->callMatch(NULL, exp->arguments, 0, &failMessage))
{
OutBuffer buf;
@@ -3495,10 +5450,11 @@ public:
tthis->modToBuffer(&buf);
//printf("tf = %s, args = %s\n", tf->deco, (*exp->arguments)[0]->type->deco);
- ::error(exp->loc, "%s %s %s is not callable using argument types %s",
+ ::error(exp->loc, "%s `%s%s` is not callable using argument types `%s`",
p, exp->e1->toChars(), parametersTypeToChars(tf->parameterList),
buf.peekChars());
-
+ if (failMessage)
+ errorSupplemental(exp->loc, failMessage);
return setError();
}
@@ -3553,13 +5509,14 @@ public:
assert(exp->f);
tiargs = NULL;
- if (ve->hasOverloads)
+ if (exp->f->overnext)
exp->f = resolveFuncCall(exp->loc, sc, exp->f, tiargs, NULL, exp->arguments, 2);
else
{
exp->f = exp->f->toAliasFunc();
TypeFunction *tf = (TypeFunction *)exp->f->type;
- if (!tf->callMatch(NULL, exp->arguments))
+ const char *failMessage = NULL;
+ if (!tf->callMatch(NULL, exp->arguments, 0, &failMessage))
{
OutBuffer buf;
@@ -3568,10 +5525,11 @@ public:
buf.writeByte(')');
//printf("tf = %s, args = %s\n", tf->deco, (*exp->arguments)[0]->type->deco);
- ::error(exp->loc, "%s %s is not callable using argument types %s",
- exp->e1->toChars(), parametersTypeToChars(tf->parameterList),
+ ::error(exp->loc, "%s `%s%s` is not callable using argument types `%s`",
+ exp->f->kind(), exp->e1->toChars(), parametersTypeToChars(tf->parameterList),
buf.peekChars());
-
+ if (failMessage)
+ errorSupplemental(exp->loc, failMessage);
exp->f = NULL;
}
}
@@ -3954,6 +5912,10 @@ public:
exp->e1 = exp->e1->castTo(sc, exp->type->pointerTo());
break;
+ case Tnull:
+ exp->type = Type::tnoreturn; // typeof(*null) is bottom type
+ break;
+
default:
exp->error("can only * a pointer, not a `%s`", exp->e1->type->toChars());
/* fall through */
@@ -7109,25 +9071,6 @@ public:
result = exp;
}
- Module *loadStdMath()
- {
- static Import *impStdMath = NULL;
- if (!impStdMath)
- {
- Identifiers *a = new Identifiers();
- a->push(Id::std);
- Import *s = new Import(Loc(), a, Id::math, NULL, false);
- s->load(NULL);
- if (s->mod)
- {
- s->mod->importAll(NULL);
- dsymbolSemantic(s->mod, NULL);
- }
- impStdMath = s;
- }
- return impStdMath->mod;
- }
-
void visit(PowExp *exp)
{
if (exp->type)
@@ -7579,7 +9522,7 @@ public:
exp->error("%s is not an expression", exp->e2->toChars());
return setError();
}
- if (e1x->op == TOKerror)
+ if (e1x->op == TOKerror || e1x->type->ty == Tnoreturn)
{
result = e1x;
return;
@@ -8032,10 +9975,18 @@ public:
Type *t1 = exp->e1->type;
Type *t2 = exp->e2->type;
+ if (t1->ty == Tnoreturn)
+ {
+ exp->type = t2;
+ }
+ else if (t2->ty == Tnoreturn)
+ {
+ exp->type = t1;
+ }
// If either operand is void the result is void, we have to cast both
// the expression to void so that we explicitly discard the expression
// value if any (bugzilla 16598)
- if (t1->ty == Tvoid || t2->ty == Tvoid)
+ else if (t1->ty == Tvoid || t2->ty == Tvoid)
{
exp->type = Type::tvoid;
exp->e1 = exp->e1->castTo(sc, exp->type);
@@ -1473,7 +1473,8 @@ FuncDeclaration *resolveFuncCall(Loc loc, Scope *sc, Dsymbol *s,
memset(&m, 0, sizeof(m));
m.last = MATCHnomatch;
- functionResolve(&m, s, loc, sc, tiargs, tthis, fargs);
+ const char *failMessage = NULL;
+ functionResolve(&m, s, loc, sc, tiargs, tthis, fargs, &failMessage);
if (m.last > MATCHnomatch && m.lastf)
{
@@ -1555,20 +1556,23 @@ FuncDeclaration *resolveFuncCall(Loc loc, Scope *sc, Dsymbol *s,
::error(loc, "none of the overloads of `%s` are callable using a %sobject, candidates are:",
fd->ident->toChars(), thisBuf.peekChars());
else
- ::error(loc, "%smethod %s is not callable using a %sobject",
+ ::error(loc, "%smethod `%s` is not callable using a %sobject",
funcBuf.peekChars(), fd->toPrettyChars(), thisBuf.peekChars());
}
else
{
//printf("tf = %s, args = %s\n", tf->deco, (*fargs)[0]->type->deco);
if (hasOverloads)
- ::error(loc, "none of the overloads of `%s` are callable using argument types %s, candidates are:",
+ ::error(loc, "none of the overloads of `%s` are callable using argument types `%s`, candidates are:",
fd->ident->toChars(), fargsBuf.peekChars());
else
- fd->error(loc, "%s%s is not callable using argument types %s",
- parametersTypeToChars(tf->parameterList),
- tf->modToChars(),
- fargsBuf.peekChars());
+ {
+ fd->error(loc, "%s `%s%s%s` is not callable using argument types `%s`",
+ fd->kind(), fd->toPrettyChars(), parametersTypeToChars(tf->parameterList),
+ tf->modToChars(), fargsBuf.peekChars());
+ if (failMessage)
+ errorSupplemental(loc, failMessage);
+ }
}
// Display candidate functions
@@ -122,7 +122,7 @@ public:
void visit(CompileStatement *s)
{
buf->writestring("mixin(");
- s->exp->accept(this);
+ argsToBuffer(s->exps);
buf->writestring(");");
if (!hgs->forStmtInit)
buf->writenl();
@@ -1104,6 +1104,18 @@ public:
buf->writestring("typeof(null)");
}
+ void visit(TypeMixin *t)
+ {
+ buf->writestring("mixin(");
+ argsToBuffer(t->exps);
+ buf->writeByte(')');
+ }
+
+ void visit(TypeNoreturn *)
+ {
+ buf->writestring("noreturn");
+ }
+
////////////////////////////////////////////////////////////////////////////
void visit(Dsymbol *s)
@@ -1418,7 +1430,7 @@ public:
void visit(CompileDeclaration *d)
{
buf->writestring("mixin(");
- d->exp->accept(this);
+ argsToBuffer(d->exps);
buf->writestring(");");
buf->writenl();
}
@@ -2408,8 +2420,15 @@ public:
buf->writeByte(')');
if (target.ptrsize == 8)
goto L4;
- else
+ else if (target.ptrsize == 4 ||
+ target.ptrsize == 2)
goto L3;
+ else
+ assert(0);
+
+ case Tvoid:
+ buf->writestring("cast(void)0");
+ break;
default:
/* This can happen if errors, such as
@@ -2822,7 +2841,7 @@ public:
void visit(CompileExp *e)
{
buf->writestring("mixin(");
- expToBuffer(e->e1, PREC_assign);
+ argsToBuffer(e->exps);
buf->writeByte(')');
}
@@ -3528,6 +3547,13 @@ void arrayObjectsToBuffer(OutBuffer *buf, Objects *objects)
}
}
+/*************************************************************
+ * Pretty print function parameters.
+ * Params:
+ * parameters = parameters to print, such as TypeFunction.parameters.
+ * varargs = kind of varargs, see TypeFunction.varargs.
+ * Returns: Null-terminated string representing parameters.
+ */
const char *parametersTypeToChars(ParameterList pl)
{
OutBuffer buf;
@@ -3536,3 +3562,26 @@ const char *parametersTypeToChars(ParameterList pl)
v.parametersToBuffer(pl.parameters, pl.varargs);
return buf.extractChars();
}
+
+/*************************************************************
+ * Pretty print function parameter.
+ * Params:
+ * parameter = parameter to print.
+ * tf = TypeFunction which holds parameter.
+ * fullQual = whether to fully qualify types.
+ * Returns: Null-terminated string representing parameters.
+ */
+const char *parameterToChars(Parameter *parameter, TypeFunction *tf, bool fullQual)
+{
+ OutBuffer buf;
+ HdrGenState hgs;
+ hgs.fullQual = fullQual;
+ PrettyPrintVisitor v(&buf, &hgs);
+
+ parameter->accept(&v);
+ if (tf->parameterList.varargs == 2 && parameter == tf->parameterList[tf->parameterList.parameters->length - 1])
+ {
+ buf.writestring("...");
+ }
+ return buf.extractChars();
+}
@@ -47,6 +47,7 @@ void arrayObjectsToBuffer(OutBuffer *buf, Objects *objects);
void moduleToBuffer(OutBuffer *buf, Module *m);
const char *parametersTypeToChars(ParameterList pl);
+const char *parameterToChars(Parameter *parameter, TypeFunction *tf, bool fullQual);
bool stcToBuffer(OutBuffer *buf, StorageClass stc);
const char *stcToChars(StorageClass& stc);
@@ -86,10 +86,16 @@ Msgtable msgtable[] =
{ "__c_longlong", NULL },
{ "__c_ulonglong", NULL },
{ "__c_long_double", NULL },
+ { "__c_wchar_t", NULL },
+ { "__c_complex_float", NULL },
+ { "__c_complex_double", NULL },
+ { "__c_complex_real", NULL },
{ "cpp_type_info_ptr", "__cpp_type_info_ptr" },
{ "_assert", "assert" },
{ "_unittest", "unittest" },
{ "_body", "body" },
+ { "printf", NULL },
+ { "scanf", NULL },
{ "TypeInfo", NULL },
{ "TypeInfo_Class", NULL },
@@ -395,7 +401,6 @@ Msgtable msgtable[] =
{ "derivedMembers", NULL },
{ "isSame", NULL },
{ "compiles", NULL },
- { "parameters", NULL },
{ "getAliasThis", NULL },
{ "getAttributes", NULL },
{ "getFunctionAttributes", NULL },
@@ -411,6 +416,7 @@ Msgtable msgtable[] =
{ "getLocation", NULL },
{ "hasPostblit", NULL },
{ "isCopyable", NULL },
+ { "toType", NULL },
// For C++ mangling
{ "allocator", NULL },
@@ -47,6 +47,7 @@ public:
Dsymbol *syntaxCopy(Dsymbol *s); // copy only syntax trees
void load(Scope *sc);
void importAll(Scope *sc);
+ void addPackageAccess(ScopeDsymbol *scopesym);
Dsymbol *toAlias();
void addMember(Scope *sc, ScopeDsymbol *sds);
void setScope(Scope* sc);
@@ -75,6 +75,7 @@ public:
unsigned numlines; // number of lines in source file
int isDocFile; // if it is a documentation input file, not D source
bool isPackageFile; // if it is a package.d
+ Package *pkg; // if isPackageFile is true, the Package that contains this package.d
Strings contentImportedFiles; // array of files whose content was imported
int needmoduleinfo;
@@ -39,6 +39,7 @@ Expression *extractSideEffect(Scope *sc, const char *name, Expression **e0, Expr
Expression *resolve(Loc loc, Scope *sc, Dsymbol *s, bool hasOverloads);
Expression *typeToExpression(Type *t);
Expression *typeToExpressionHelper(TypeQualified *t, Expression *e, size_t i = 0);
+RootObject *compileTypeMixin(TypeMixin *tm, Loc loc, Scope *sc);
/***************************** Type *****************************/
@@ -93,6 +94,7 @@ Type *Type::tdchar;
Type *Type::tshiftcnt;
Type *Type::terror;
Type *Type::tnull;
+Type *Type::tnoreturn;
Type *Type::tsize_t;
Type *Type::tptrdiff_t;
@@ -195,6 +197,8 @@ void Type::_init()
sizeTy[Tnull] = sizeof(TypeNull);
sizeTy[Tvector] = sizeof(TypeVector);
sizeTy[Ttraits] = sizeof(TypeTraits);
+ sizeTy[Tmixin] = sizeof(TypeMixin);
+ sizeTy[Tnoreturn] = sizeof(TypeNoreturn);
initTypeMangle();
@@ -216,6 +220,10 @@ void Type::_init()
}
basic[Terror] = new TypeError();
+ tnoreturn = new TypeNoreturn();
+ tnoreturn->deco = tnoreturn->merge()->deco;
+ basic[Tnoreturn] = tnoreturn;
+
tvoid = basic[Tvoid];
tint8 = basic[Tint8];
tuns8 = basic[Tuns8];
@@ -246,7 +254,7 @@ void Type::_init()
tshiftcnt = tint32;
terror = basic[Terror];
- tnull = basic[Tnull];
+ tnoreturn = basic[Tnoreturn];
tnull = new TypeNull();
tnull->deco = tnull->merge()->deco;
@@ -2079,7 +2087,7 @@ Expression *Type::getProperty(Loc loc, Identifier *ident, int flag)
if (this != Type::terror)
{
if (s)
- error(loc, "no property `%s` for type `%s`, did you mean `%s`?", ident->toChars(), toChars(), s->toChars());
+ error(loc, "no property `%s` for type `%s`, did you mean `%s`?", ident->toChars(), toChars(), s->toPrettyChars());
else
error(loc, "no property `%s` for type `%s`", ident->toChars(), toChars());
}
@@ -2413,6 +2421,16 @@ TypeTraits *Type::isTypeTraits()
return ty == Ttraits ? (TypeTraits *)this : NULL;
}
+TypeMixin *Type::isTypeMixin()
+{
+ return ty == Tmixin ? (TypeMixin *)this : NULL;
+}
+
+TypeNoreturn *Type::isTypeNoreturn()
+{
+ return ty == Tnoreturn ? (TypeNoreturn *)this : NULL;
+}
+
TypeFunction *Type::toTypeFunction()
{
if (ty != Tfunction)
@@ -5175,16 +5193,47 @@ void TypeFunction::purityLevel()
tf->purity = purity;
}
+// arguments get specially formatted
+static const char *getParamError(TypeFunction *tf, Expression *arg, Parameter *par)
+{
+ if (global.gag && !global.params.showGaggedErrors)
+ return NULL;
+ // show qualification when toChars() is the same but types are different
+ const char *at = arg->type->toChars();
+ bool qual = !arg->type->equals(par->type) && strcmp(at, par->type->toChars()) == 0;
+ if (qual)
+ at = arg->type->toPrettyChars(true);
+ OutBuffer buf;
+ // only mention rvalue if it's relevant
+ const bool rv = !arg->isLvalue() && (par->storageClass & (STCref | STCout)) != 0;
+ buf.printf("cannot pass %sargument `%s` of type `%s` to parameter `%s`",
+ rv ? "rvalue " : "", arg->toChars(), at,
+ parameterToChars(par, tf, qual));
+ return buf.extractChars();
+}
+
+static const char *getMatchError(const char *format, ...)
+{
+ if (global.gag && !global.params.showGaggedErrors)
+ return NULL;
+ OutBuffer buf;
+ va_list ap;
+ va_start(ap, format);
+ buf.vprintf(format, ap);
+ return buf.extractChars();
+}
+
/********************************
* 'args' are being matched to function 'this'
* Determine match level.
* Input:
* flag 1 performing a partial ordering match
+ * pMessage address to store error message, or null
* Returns:
* MATCHxxxx
*/
-MATCH TypeFunction::callMatch(Type *tthis, Expressions *args, int flag)
+MATCH TypeFunction::callMatch(Type *tthis, Expressions *args, int flag, const char **pMessage)
{
//printf("TypeFunction::callMatch() %s\n", toChars());
MATCH match = MATCHexact; // assume exact match
@@ -5221,12 +5270,15 @@ MATCH TypeFunction::callMatch(Type *tthis, Expressions *args, int flag)
size_t nparams = parameterList.length();
size_t nargs = args ? args->length : 0;
- if (nparams == nargs)
- ;
- else if (nargs > nparams)
+ if (nargs > nparams)
{
if (parameterList.varargs == VARARGnone)
- goto Nomatch; // too many args; no match
+ {
+ // suppress early exit if an error message is wanted,
+ // so we can check any matching args are valid
+ if (!pMessage)
+ goto Nomatch; // too many args; no match
+ }
match = MATCHconvert; // match ... with a "conversion" match level
}
@@ -5309,7 +5361,10 @@ MATCH TypeFunction::callMatch(Type *tthis, Expressions *args, int flag)
if (m && !arg->isLvalue())
{
if (p->storageClass & STCout)
+ {
+ if (pMessage) *pMessage = getParamError(this, arg, p);
goto Nomatch;
+ }
if (arg->op == TOKstring && tp->ty == Tsarray)
{
@@ -5331,7 +5386,10 @@ MATCH TypeFunction::callMatch(Type *tthis, Expressions *args, int flag)
}
}
else
+ {
+ if (pMessage) *pMessage = getParamError(this, arg, p);
goto Nomatch;
+ }
}
/* Find most derived alias this type being matched.
@@ -5351,7 +5409,10 @@ MATCH TypeFunction::callMatch(Type *tthis, Expressions *args, int flag)
* ref T[dim] <- an lvalue of const(T[dim]) argument
*/
if (!ta->constConv(tp))
+ {
+ if (pMessage) *pMessage = getParamError(this, arg, p);
goto Nomatch;
+ }
}
}
@@ -5377,7 +5438,11 @@ MATCH TypeFunction::callMatch(Type *tthis, Expressions *args, int flag)
tsa = (TypeSArray *)tb;
sz = tsa->dim->toInteger();
if (sz != nargs - u)
+ {
+ if (pMessage)
+ *pMessage = getMatchError("expected %llu variadic argument(s), not %zu", sz, nargs - u);
goto Nomatch;
+ }
/* fall through */
case Tarray:
{
@@ -5408,7 +5473,10 @@ MATCH TypeFunction::callMatch(Type *tthis, Expressions *args, int flag)
m = arg->implicitConvTo(ta->next);
if (m == MATCHnomatch)
+ {
+ if (pMessage) *pMessage = getParamError(this, arg, p);
goto Nomatch;
+ }
if (m < match)
match = m;
}
@@ -5420,9 +5488,14 @@ MATCH TypeFunction::callMatch(Type *tthis, Expressions *args, int flag)
goto Ldone;
default:
- goto Nomatch;
+ break;
}
}
+ if (pMessage && u < nargs)
+ *pMessage = getParamError(this, (*args)[u], p);
+ else if (pMessage)
+ *pMessage = getMatchError("missing argument for parameter #%d: `%s`",
+ u + 1, parameterToChars(p, this, false));
goto Nomatch;
}
if (m < match)
@@ -5430,6 +5503,12 @@ MATCH TypeFunction::callMatch(Type *tthis, Expressions *args, int flag)
}
Ldone:
+ if (pMessage && !parameterList.varargs && nargs > nparams)
+ {
+ // all parameters had a match, but there are surplus args
+ *pMessage = getMatchError("expected %d argument(s), not %d", nparams, nargs);
+ goto Nomatch;
+ }
//printf("match = %d\n", match);
return match;
@@ -5797,6 +5876,20 @@ Type *TypeTraits::syntaxCopy()
return tt;
}
+Dsymbol *TypeTraits::toDsymbol(Scope *sc)
+{
+ Type *t = NULL;
+ Expression *e = NULL;
+ Dsymbol *s = NULL;
+ resolve(loc, sc, &e, &t, &s);
+ if (t && t->ty != Terror)
+ s = t->toDsymbol(sc);
+ else if (e)
+ s = getDsymbol(e);
+
+ return s;
+}
+
void TypeTraits::resolve(Loc loc, Scope *sc, Expression **pe, Type **pt, Dsymbol **ps, bool)
{
*pt = NULL;
@@ -5816,6 +5909,90 @@ d_uns64 TypeTraits::size(Loc)
return SIZE_INVALID;
}
+/***************************** TypeMixin *****************************/
+
+/******
+ * Implements mixin types.
+ *
+ * Semantic analysis will convert it to a real type.
+ */
+TypeMixin::TypeMixin(const Loc &loc, Expressions *exps)
+ : Type(Tmixin)
+{
+ this->loc = loc;
+ this->exps = exps;
+ this->obj = NULL; // cached result of semantic analysis.
+}
+
+const char *TypeMixin::kind()
+{
+ return "mixin";
+}
+
+Type *TypeMixin::syntaxCopy()
+{
+ return new TypeMixin(loc, Expression::arraySyntaxCopy(exps));
+}
+
+Dsymbol *TypeMixin::toDsymbol(Scope *sc)
+{
+ Type *t = NULL;
+ Expression *e = NULL;
+ Dsymbol *s = NULL;
+ resolve(loc, sc, &e, &t, &s);
+ if (t)
+ s = t->toDsymbol(sc);
+ else if (e)
+ s = getDsymbol(e);
+
+ return s;
+}
+
+void TypeMixin::resolve(Loc loc, Scope *sc, Expression **pe, Type **pt, Dsymbol **ps, bool intypeid)
+{
+ // if already resolved just set pe/pt/ps and return.
+ if (obj)
+ {
+ *pe = isExpression(obj);
+ *pt = isType(obj);
+ *ps = isDsymbol(obj);
+ return;
+ }
+
+ RootObject *o = compileTypeMixin(this, loc, sc);
+ if (Type *t = isType(o))
+ {
+ t->resolve(loc, sc, pe, pt, ps, intypeid);
+ if (*pt)
+ (*pt) = (*pt)->addMod(mod);
+ }
+ else if (Expression *e = isExpression(o))
+ {
+ e = expressionSemantic(e, sc);
+ if (TypeExp *et = e->isTypeExp())
+ {
+ *pe = NULL;
+ *pt = et->type->addMod(mod);
+ *ps = NULL;
+ }
+ else
+ {
+ *pe = e;
+ *pt = NULL;
+ *ps = NULL;
+ }
+ }
+ else
+ {
+ *pe = NULL;
+ *pt = Type::terror;
+ *ps = NULL;
+ }
+
+ // save the result
+ obj = *pe ? (RootObject *)*pe : (*pt ? (RootObject *)*pt : (RootObject *)*ps);
+}
+
/***************************** TypeQualified *****************************/
TypeQualified::TypeQualified(TY ty, Loc loc)
@@ -6003,11 +6180,25 @@ void TypeQualified::resolveHelper(Loc loc, Scope *sc,
Type *t = s->getType(); // type symbol, type alias, or type tuple?
unsigned errorsave = global.errors;
- Dsymbol *sm = s->searchX(loc, sc, id);
- if (sm && !(sc->flags & SCOPEignoresymbolvisibility) && !symbolIsVisible(sc, sm))
+ int flags = t == NULL ? SearchLocalsOnly : IgnorePrivateImports;
+ Dsymbol *sm = s->searchX(loc, sc, id, flags);
+ if (sm)
{
- ::error(loc, "`%s` is not visible from module `%s`", sm->toPrettyChars(), sc->_module->toChars());
- sm = NULL;
+ if (!(sc->flags & SCOPEignoresymbolvisibility) && !symbolIsVisible(sc, sm))
+ {
+ ::error(loc, "`%s` is not visible from module `%s`", sm->toPrettyChars(), sc->_module->toChars());
+ sm = NULL;
+ }
+ // Same check as in Expression::semanticY(DotIdExp)
+ else if (sm->isPackage() && checkAccess(sc, (Package *)sm))
+ {
+ // @@@DEPRECATED_2.096@@@
+ // 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)
{
@@ -6052,7 +6243,7 @@ void TypeQualified::resolveHelper(Loc loc, Scope *sc,
sm = t->toDsymbol(sc);
if (sm && id->dyncast() == DYNCAST_IDENTIFIER)
{
- sm = sm->search(loc, (Identifier *)id);
+ sm = sm->search(loc, (Identifier *)id, IgnorePrivateImports);
if (sm)
goto L2;
}
@@ -8177,6 +8368,49 @@ Expression *TypeNull::defaultInit(Loc)
return new NullExp(Loc(), Type::tnull);
}
+/***************************** TypeNoreturn *****************************/
+
+TypeNoreturn::TypeNoreturn()
+ : Type(Tnoreturn)
+{
+ //printf("TypeNoreturn %p\n", this);
+}
+
+const char *TypeNoreturn::kind()
+{
+ return "noreturn";
+}
+
+Type *TypeNoreturn::syntaxCopy()
+{
+ // No semantic analysis done, no need to copy
+ return this;
+}
+
+MATCH TypeNoreturn::implicitConvTo(Type *to)
+{
+ //printf("TypeNoreturn::implicitConvTo(this=%p, to=%p)\n", this, to);
+ //printf("from: %s\n", toChars());
+ //printf("to : %s\n", to.toChars());
+ MATCH m = Type::implicitConvTo(to);
+ return (m == MATCHexact) ? MATCHexact : MATCHconvert;
+}
+
+bool TypeNoreturn::isBoolean()
+{
+ return true; // bottom type can be implicitly converted to any other type
+}
+
+d_uns64 TypeNoreturn::size(Loc)
+{
+ return 0;
+}
+
+unsigned TypeNoreturn::alignsize()
+{
+ return 0;
+}
+
/***********************************************************
* Encapsulate Parameters* so .length and [i] can be used on it.
* https://dlang.org/spec/function.html#ParameterList
@@ -8472,3 +8706,25 @@ bool Parameter::isCovariantScope(bool returnByRef, StorageClass from, StorageCla
return covariant[SR::buildSR(returnByRef, from)][SR::buildSR(returnByRef, to)];
}
+
+/**
+ * For printing two types with qualification when necessary.
+ * Params:
+ * t1 = The first type to receive the type name for
+ * t2 = The second type to receive the type name for
+ * Returns:
+ * The fully-qualified names of both types if the two type names are not the same,
+ * or the unqualified names of both types if the two type names are the same.
+ */
+void toAutoQualChars(const char **result, Type *t1, Type *t2)
+{
+ const char *s1 = t1->toChars();
+ const char *s2 = t2->toChars();
+ if (strcmp(s1, s2) == 0)
+ {
+ s1 = t1->toPrettyChars(true);
+ s2 = t2->toPrettyChars(true);
+ }
+ result[0] = s1;
+ result[1] = s2;
+}
@@ -96,6 +96,8 @@ enum ENUMTY
Tint128,
Tuns128,
Ttraits,
+ Tmixin,
+ Tnoreturn,
TMAX
};
typedef unsigned char TY; // ENUMTY
@@ -201,6 +203,7 @@ public:
static Type *tdstring; // immutable(dchar)[]
static Type *terror; // for error recovery
static Type *tnull; // for null type
+ static Type *tnoreturn; // for bottom type typeof(*null)
static Type *tsize_t; // matches size_t alias
static Type *tptrdiff_t; // matches ptrdiff_t alias
@@ -367,7 +370,9 @@ public:
TypeTuple *isTypeTuple();
TypeSlice *isTypeSlice();
TypeNull *isTypeNull();
+ TypeMixin *isTypeMixin();
TypeTraits *isTypeTraits();
+ TypeNoreturn *isTypeNoreturn();
void accept(Visitor *v) { v->visit(this); }
};
@@ -686,7 +691,7 @@ public:
int attributesApply(void *param, int (*fp)(void *, const char *), TRUSTformat trustFormat = TRUSTformatDefault);
Type *substWildTo(unsigned mod);
- MATCH callMatch(Type *tthis, Expressions *toargs, int flag = 0);
+ MATCH callMatch(Type *tthis, Expressions *toargs, int flag = 0, const char **pMessage = NULL);
bool checkRetType(Loc loc);
Expression *defaultInit(Loc loc) /*const*/;
@@ -726,11 +731,27 @@ public:
TypeTraits(const Loc &loc, TraitsExp *exp);
Type *syntaxCopy();
+ Dsymbol *toDsymbol(Scope *sc);
void resolve(Loc loc, Scope *sc, Expression **pe, Type **pt, Dsymbol **ps, bool intypeid = false);
d_uns64 size(Loc loc);
void accept(Visitor *v) { v->visit(this); }
};
+class TypeMixin : public Type
+{
+public:
+ Loc loc;
+ Expressions *exps;
+ RootObject *obj;
+
+ TypeMixin(const Loc &loc, Expressions *exps);
+ const char *kind();
+ Type *syntaxCopy();
+ Dsymbol *toDsymbol(Scope *sc);
+ void resolve(Loc loc, Scope *sc, Expression **pe, Type **pt, Dsymbol **ps, bool intypeid = false);
+ void accept(Visitor *v) { v->visit(this); }
+};
+
class TypeQualified : public Type
{
public:
@@ -966,6 +987,21 @@ public:
void accept(Visitor *v) { v->visit(this); }
};
+class TypeNoreturn : public Type
+{
+public:
+ TypeNoreturn();
+ const char *kind();
+
+ Type *syntaxCopy();
+ MATCH implicitConvTo(Type *to);
+ bool isBoolean() /*const*/;
+
+ d_uns64 size(Loc loc) /*const*/;
+ unsigned alignsize();
+ void accept(Visitor *v) { v->visit(this); }
+};
+
/**************************************************************/
bool arrayTypeCompatible(Loc loc, Type *t1, Type *t2);
@@ -328,11 +328,9 @@ Dsymbols *Parser::parseDeclDefs(int once, Dsymbol **pLastDecl, PrefixAttributes
{
// mixin(string)
nextToken();
- check(TOKlparen, "mixin");
- Expression *e = parseAssignExp();
- check(TOKrparen);
+ Expressions *exps = parseArguments();
check(TOKsemicolon);
- s = new CompileDeclaration(loc, e);
+ s = new CompileDeclaration(loc, exps);
break;
}
case TOKtemplate:
@@ -1336,7 +1334,7 @@ LINK Parser::parseLinkage(Identifiers **pidents, CPPMANGLE *pcppmangle, bool *pc
}
else if (!Identifier::isValidIdentifier(name))
{
- error("expected valid identifer for C++ namespace but got `%s`", name);
+ error("expected valid identifier for C++ namespace but got `%s`", name);
idents = NULL;
break;
}
@@ -2922,6 +2920,18 @@ Objects *Parser::parseTemplateArguments()
return tiargs;
}
+/***************************************
+ * Parse a Type or an Expression
+ * Returns:
+ * RootObject representing the AST
+ */
+RootObject *Parser::parseTypeOrAssignExp(TOK endtoken)
+{
+ return isDeclaration(&token, 0, endtoken, NULL)
+ ? (RootObject *)parseType() // argument is a type
+ : (RootObject *)parseAssignExp(); // argument is an expression
+}
+
/******************************************
* Parse template argument list.
* Input:
@@ -2942,20 +2952,10 @@ Objects *Parser::parseTemplateArgumentList()
// Get TemplateArgumentList
while (token.value != endtok)
{
- // See if it is an Expression or a Type
- if (isDeclaration(&token, 0, TOKreserved, NULL))
- { // Template argument is a type
- Type *ta = parseType();
- tiargs->push(ta);
- }
- else
- { // Template argument is an expression
- Expression *ea = parseAssignExp();
- tiargs->push(ea);
- }
- if (token.value != TOKcomma)
- break;
- nextToken();
+ tiargs->push(parseTypeOrAssignExp());
+ if (token.value != TOKcomma)
+ break;
+ nextToken();
}
check(endtok, "template argument list");
return tiargs;
@@ -3288,6 +3288,15 @@ Type *Parser::parseBasicType(bool dontLookDotIdents)
}
break;
+ case TOKmixin:
+ // https://dlang.org/spec/expression.html#mixin_types
+ loc = token.loc;
+ nextToken();
+ if (token.value != TOKlparen)
+ error("found `%s` when expecting `%s` following %s", token.toChars(), Token::toChars(TOKlparen), "`mixin`");
+ t = new TypeMixin(loc, parseArguments());
+ break;
+
case TOKdot:
// Leading . as in .foo
t = parseBasicTypeStartingAt(new TypeIdentifier(token.loc, Id::empty), dontLookDotIdents);
@@ -3602,7 +3611,7 @@ Type *Parser::parseDeclarator(Type *t, int *palt, Identifier **pident,
if (pident)
*pident = token.ident;
else
- error("unexpected identifer `%s` in declarator", token.ident->toChars());
+ error("unexpected identifier `%s` in declarator", token.ident->toChars());
ts = t;
nextToken();
break;
@@ -3863,6 +3872,21 @@ void Parser::parseStorageClasses(StorageClass &storage_class, LINK &link,
}
}
+static void parseAttributes(Parser *p, bool &hasParsedAttributes,
+ StorageClass &storage_class, LINK &link, bool &setAlignment,
+ Expression *&ealign, Expressions *&udas)
+{
+ if (hasParsedAttributes) // only parse once
+ return;
+ hasParsedAttributes = true;
+ udas = NULL;
+ storage_class = STCundefined;
+ link = p->linkage;
+ setAlignment = false;
+ ealign = NULL;
+ p->parseStorageClasses(storage_class, link, setAlignment, ealign, udas);
+}
+
/**********************************
* Parse Declarations.
* These can be:
@@ -3936,26 +3960,48 @@ Dsymbols *Parser::parseDeclarations(bool autodecl, PrefixAttributes *pAttrs, con
bool hasParsedAttributes = false;
if (token.value == TOKat)
{
- if (!hasParsedAttributes)
- {
- hasParsedAttributes = true;
- storage_class = STCundefined;
- link = linkage;
- setAlignment = false;
- ealign = NULL;
- udas = NULL;
- parseStorageClasses(storage_class, link, setAlignment, ealign, udas);
- }
+ parseAttributes(this, hasParsedAttributes,
+ storage_class, link, setAlignment, ealign, udas);
}
Declaration *v;
- if (token.value == TOKfunction ||
+ Dsymbol *s;
+
+ // try to parse function type:
+ // TypeCtors? BasicType ( Parameters ) MemberFunctionAttributes
+ bool attributesAppended = false;
+ const StorageClass funcStc = parseTypeCtor();
+ Token *tlu = &token;
+ if (token.value != TOKfunction &&
+ token.value != TOKdelegate &&
+ isBasicType(&tlu) && tlu &&
+ tlu->value == TOKlparen)
+ {
+ VarArg vargs;
+ Type *tret = parseBasicType();
+ Parameters *prms = parseParameters(&vargs);
+ ParameterList pl = ParameterList(prms, vargs);
+
+ parseAttributes(this, hasParsedAttributes,
+ storage_class, link, setAlignment, ealign, udas);
+ if (udas)
+ error("user-defined attributes not allowed for `alias` declarations");
+
+ attributesAppended = true;
+ storage_class = appendStorageClass(storage_class, funcStc);
+ Type *tf = new TypeFunction(pl, tret, link, storage_class);
+ v = new AliasDeclaration(loc, ident, tf);
+ }
+ else if (token.value == TOKfunction ||
token.value == TOKdelegate ||
(token.value == TOKlparen &&
skipAttributes(peekPastParen(&token), &tk) &&
(tk->value == TOKgoesto || tk->value == TOKlcurly)) ||
token.value == TOKlcurly ||
- (token.value == TOKidentifier && peekNext() == TOKgoesto))
+ (token.value == TOKidentifier && peekNext() == TOKgoesto) ||
+ (token.value == TOKref && peekNext() == TOKlparen &&
+ skipAttributes(peekPastParen(peek(&token)), &tk) &&
+ (tk->value == TOKgoesto || tk->value == TOKlcurly)))
{
// function (parameters) { statements... }
// delegate (parameters) { statements... }
@@ -3963,8 +4009,10 @@ Dsymbols *Parser::parseDeclarations(bool autodecl, PrefixAttributes *pAttrs, con
// (parameters) => expression
// { statements... }
// identifier => expression
+ // ref (parameters) { statements... }
+ // ref (parameters) => expression
- Dsymbol *s = parseFunctionLiteral();
+ s = parseFunctionLiteral();
if (udas != NULL)
{
@@ -3985,26 +4033,19 @@ Dsymbols *Parser::parseDeclarations(bool autodecl, PrefixAttributes *pAttrs, con
else
{
// StorageClasses type
- if (!hasParsedAttributes)
- {
- hasParsedAttributes = true;
- storage_class = STCundefined;
- link = linkage;
- setAlignment = false;
- ealign = NULL;
- udas = NULL;
- parseStorageClasses(storage_class, link, setAlignment, ealign, udas);
- }
-
+ parseAttributes(this, hasParsedAttributes,
+ storage_class, link, setAlignment, ealign, udas);
if (udas)
error("user-defined attributes not allowed for %s declarations", Token::toChars(tok));
t = parseType();
v = new AliasDeclaration(loc, ident, t);
}
+ if (!attributesAppended)
+ storage_class = appendStorageClass(storage_class, funcStc);
v->storage_class = storage_class;
- Dsymbol *s = v;
+ s = v;
if (tpl)
{
Dsymbols *a2 = new Dsymbols();
@@ -4358,6 +4399,13 @@ Dsymbol *Parser::parseFunctionLiteral()
case TOKdelegate:
save = token.value;
nextToken();
+ if (token.value == TOKref)
+ {
+ // function ref (parameters) { statements... }
+ // delegate ref (parameters) { statements... }
+ stc = STCref;
+ nextToken();
+ }
if (token.value != TOKlparen && token.value != TOKlcurly)
{
// function type (parameters) { statements... }
@@ -4377,14 +4425,22 @@ Dsymbol *Parser::parseFunctionLiteral()
// delegate { statements... }
break;
}
- /* fall through */
+ goto LTOKlparen;
+
+ case TOKref:
+ // ref (parameters) => expression
+ // ref (parameters) { statements... }
+ stc = STCref;
+ nextToken();
+ goto LTOKlparen;
case TOKlparen:
+ LTOKlparen:
{
// (parameters) => expression
// (parameters) { statements... }
parameters = parseParameters(&varargs, &tpl);
- stc = parsePostfix(STCundefined, NULL);
+ stc = parsePostfix(stc, NULL);
if (StorageClass modStc = stc & STC_TYPECTOR)
{
if (save == TOKfunction)
@@ -5093,7 +5149,7 @@ Statement *Parser::parseForeach(Loc loc, bool *isRange, bool isDecl)
check(TOKrparen);
Loc endloc;
Statement *body = (!isDecl) ? parseStatement(0, NULL, &endloc) : NULL;
- if (isRange)
+ if (isRange)
*isRange = false;
return new ForeachStatement(loc, op, parameters, aggr, body, endloc);
}
@@ -5378,15 +5434,19 @@ Statement *Parser::parseStatement(int flags, const utf8_t** endPtr, Loc *pEndloc
}
case TOKmixin:
- { Token *t = peek(&token);
+ {
+ if (isDeclaration(&token, 3, TOKreserved, NULL))
+ goto Ldeclaration;
+ Token *t = peek(&token);
if (t->value == TOKlparen)
- { // mixin(string)
+ {
+ // mixin(string)
Expression *e = parseAssignExp();
check(TOKsemicolon);
if (e->op == TOKmixin)
{
CompileExp *cpe = (CompileExp *)e;
- s = new CompileStatement(loc, cpe->e1);
+ s = new CompileStatement(loc, cpe->exps);
}
else
{
@@ -6332,6 +6392,7 @@ bool Parser::isBasicType(Token **pt)
case TOKtypeof:
case TOKvector:
+ case TOKmixin:
/* typeof(exp).identifier...
*/
t = peek(t);
@@ -6592,9 +6653,11 @@ bool Parser::isDeclarator(Token **pt, int *haveId, int *haveTpl, TOK endtok, boo
case TOKin:
case TOKout:
case TOKdo:
+ LTOKdo:
// The !parens is to disallow unnecessary parentheses
if (!parens && (endtok == TOKreserved || endtok == t->value))
- { *pt = t;
+ {
+ *pt = t;
return true;
}
return false;
@@ -6602,6 +6665,12 @@ bool Parser::isDeclarator(Token **pt, int *haveId, int *haveTpl, TOK endtok, boo
case TOKif:
return haveTpl ? true : false;
+ // Used for mixin type parsing
+ case TOKeof:
+ if (endtok == TOKeof)
+ goto LTOKdo;
+ return false;
+
default:
Ldefault:
return false;
@@ -7229,15 +7298,7 @@ Expression *Parser::parsePrimaryExp()
{
nextToken();
check(TOKlparen, "typeid");
- RootObject *o;
- if (isDeclaration(&token, 0, TOKreserved, NULL))
- { // argument is a type
- o = parseType();
- }
- else
- { // argument is an expression
- o = parseAssignExp();
- }
+ RootObject *o = parseTypeOrAssignExp();
check(TOKrparen);
e = new TypeidExp(loc, o);
break;
@@ -7279,6 +7340,14 @@ Expression *Parser::parsePrimaryExp()
if (token.value == TOKlparen)
{
nextToken();
+ if (token.value == TOKidentifier && peekNext() == TOKlparen)
+ {
+ error(loc, "unexpected `(` after `%s`, inside `is` expression. Try enclosing the contents of `is` with a `typeof` expression", token.toChars());
+ nextToken();
+ Token *tempTok = peekPastParen(&token);
+ memcpy(&token, tempTok, sizeof(Token));
+ goto Lerr;
+ }
targ = parseType(&ident);
if (token.value == TOKcolon || token.value == TOKequal)
{
@@ -7357,11 +7426,11 @@ Expression *Parser::parsePrimaryExp()
case TOKmixin:
{
+ // https://dlang.org/spec/expression.html#mixin_expressions
nextToken();
- check(TOKlparen, "mixin");
- e = parseAssignExp();
- check(TOKrparen);
- e = new CompileExp(loc, e);
+ if (token.value != TOKlparen)
+ error("found `%s` when expecting `%s` following %s", token.toChars(), Token::toChars(TOKlparen), "`mixin`");
+ e = new CompileExp(loc, parseArguments());
break;
}
@@ -7379,6 +7448,24 @@ Expression *Parser::parsePrimaryExp()
e = parseNewExp(NULL);
break;
+ case TOKref:
+ {
+ if (peekNext() == TOKlparen)
+ {
+ Token *tk = peekPastParen(peek(&token));
+ if (skipAttributes(tk, &tk) &&
+ (tk->value == TOKgoesto || tk->value == TOKlcurly))
+ {
+ // ref (arguments) => expression
+ // ref (arguments) { statements... }
+ goto case_delegate;
+ }
+ }
+ nextToken();
+ error("found `%s` when expecting function literal following `ref`", token.toChars());
+ goto Lerr;
+ }
+
case TOKlparen:
{
Token *tk = peekPastParen(&token);
@@ -83,6 +83,7 @@ public:
TemplateParameters *parseTemplateParameterList(int flag = 0);
Dsymbol *parseMixin();
Objects *parseTemplateArguments();
+ RootObject *parseTypeOrAssignExp(TOK endtoken = TOKreserved);
Objects *parseTemplateArgumentList();
Objects *parseTemplateSingleArgument();
StaticAssert *parseStaticAssert();
@@ -66,6 +66,10 @@ enum PINLINE;
#define SCOPEfullinst 0x10000 // fully instantiate templates
#define SCOPEalias 0x20000 // inside alias declaration
+// The following are mutually exclusive
+#define SCOPEprintf 0x40000 // printf-style function
+#define SCOPEscanf 0x80000 // scanf-style function
+
struct Scope
{
Scope *enclosing; // enclosing Scope
@@ -163,6 +163,15 @@ public:
if (vd->_init && !vd->toParent()->isFuncDeclaration())
{
vd->inuse++;
+
+ /* https://issues.dlang.org/show_bug.cgi?id=20280
+ *
+ * Template instances may import modules that have not
+ * finished semantic1.
+ */
+ if (!vd->type)
+ dsymbolSemantic(vd, sc);
+
// Bugzilla 14166: Don't run CTFE for the temporary variables inside typeof
vd->_init = initializerSemantic(vd->_init, sc, vd->type, sc->intypeof == 1 ? INITnointerpret : INITinterpret);
vd->inuse--;
@@ -265,6 +274,17 @@ public:
{
if (fd->semanticRun >= PASSsemantic2done)
return;
+
+ if (fd->semanticRun < PASSsemanticdone && !fd->errors)
+ {
+ /* https://issues.dlang.org/show_bug.cgi?id=21614
+ *
+ * Template instances may import modules that have not
+ * finished semantic1.
+ */
+ dsymbolSemantic(fd, sc);
+ }
+
assert(fd->semanticRun <= PASSsemantic2);
fd->semanticRun = PASSsemantic2;
@@ -850,32 +850,18 @@ public:
}
assert(!funcdecl->returnLabel);
}
+ else if (f->next->ty == Tnoreturn)
+ {
+ }
else
{
const bool inlineAsm = (funcdecl->hasReturnExp & 8) != 0;
if ((blockexit & BEfallthru) && f->next->ty != Tvoid && !inlineAsm)
{
- Expression *e;
if (!funcdecl->hasReturnExp)
- funcdecl->error("has no return statement, but is expected to return a value of type %s", f->next->toChars());
- else
- funcdecl->error("no return exp; or assert(0); at end of function");
- if (global.params.useAssert == CHECKENABLEon &&
- !global.params.useInline)
- {
- /* Add an assert(0, msg); where the missing return
- * should be.
- */
- e = new AssertExp(funcdecl->endloc,
- new IntegerExp(0),
- new StringExp(funcdecl->loc, const_cast<char *>("missing return expression")));
- }
+ funcdecl->error("has no `return` statement, but is expected to return a value of type `%s`", f->next->toChars());
else
- e = new HaltExp(funcdecl->endloc);
- e = new CommaExp(Loc(), e, f->next->defaultInit());
- e = expressionSemantic(e, sc2);
- Statement *s = new ExpStatement(Loc(), e);
- funcdecl->fbody = new CompoundStatement(Loc(), funcdecl->fbody, s);
+ funcdecl->error("no `return exp;` or `assert(0);` at end of function");
}
}
@@ -1162,15 +1148,7 @@ public:
if (cd)
{
- if (!global.params.is64bit &&
- global.params.isWindows &&
- !funcdecl->isStatic() && !sbody->usesEH() && !global.params.trace)
- {
- /* The back end uses the "jmonitor" hack for syncing;
- * no need to do the sync at this level.
- */
- }
- else
+ if (target.libraryObjectMonitors(funcdecl, sbody))
{
Expression *vsync;
if (funcdecl->isStatic())
@@ -31,6 +31,7 @@ StorageClass mergeFuncAttrs(StorageClass s1, FuncDeclaration *f);
bool checkEscapeRef(Scope *sc, Expression *e, bool gag);
VarDeclaration *copyToTemp(StorageClass stc, const char *name, Expression *e);
Statement *makeTupleForeachStatic(Scope *sc, ForeachStatement *fs, bool needExpansion);
+bool expressionsToString(OutBuffer &buf, Scope *sc, Expressions *exps);
Identifier *fixupLabelName(Scope *sc, Identifier *ident)
{
@@ -504,12 +505,19 @@ Statement *DtorExpStatement::syntaxCopy()
CompileStatement::CompileStatement(Loc loc, Expression *exp)
: Statement(loc)
{
- this->exp = exp;
+ this->exps = new Expressions();
+ this->exps->push(exp);
+}
+
+CompileStatement::CompileStatement(Loc loc, Expressions *exps)
+ : Statement(loc)
+{
+ this->exps = exps;
}
Statement *CompileStatement::syntaxCopy()
{
- return new CompileStatement(loc, exp->syntaxCopy());
+ return new CompileStatement(loc, Expression::arraySyntaxCopy(exps));
}
static Statements *errorStatements()
@@ -519,32 +527,36 @@ static Statements *errorStatements()
return a;
}
-Statements *CompileStatement::flatten(Scope *sc)
+static Statements *compileIt(CompileStatement *cs, Scope *sc)
{
- //printf("CompileStatement::flatten() %s\n", exp->toChars());
- StringExp *se = semanticString(sc, exp, "argument to mixin");
- if (!se)
+ //printf("CompileStatement::compileIt() %s\n", exp->toChars());
+ OutBuffer buf;
+ if (expressionsToString(buf, sc, cs->exps))
return errorStatements();
- se = se->toUTF8(sc);
unsigned errors = global.errors;
- Parser p(loc, sc->_module, (utf8_t *)se->string, se->len, 0);
+ const size_t len = buf.length();
+ const char *str = buf.extractChars();
+ Parser p(cs->loc, sc->_module, (const utf8_t *)str, len, false);
p.nextToken();
Statements *a = new Statements();
while (p.token.value != TOKeof)
{
Statement *s = p.parseStatement(PSsemi | PScurlyscope);
- if (!s || p.errors)
- {
- assert(!p.errors || global.errors != errors); // make sure we caught all the cases
+ if (!s || global.errors != errors)
return errorStatements();
- }
a->push(s);
}
return a;
}
+Statements *CompileStatement::flatten(Scope *sc)
+{
+ //printf("CompileStatement::flatten() %s\n", exp->toChars());
+ return compileIt(this, sc);
+}
+
/******************************** CompoundStatement ***************************/
CompoundStatement::CompoundStatement(Loc loc, Statements *s)
@@ -173,9 +173,10 @@ public:
class CompileStatement : public Statement
{
public:
- Expression *exp;
+ Expressions *exps;
CompileStatement(Loc loc, Expression *exp);
+ CompileStatement(Loc loc, Expressions *exps);
Statement *syntaxCopy();
Statements *flatten(Scope *sc);
void accept(Visitor *v) { v->visit(this); }
@@ -581,7 +581,7 @@ public:
{
fs->error("constant value %s cannot be ref", ie->toChars());
}
- else
+ else
{
fs->error("constant value %s cannot be ref", ident->toChars());
}
@@ -21,6 +21,7 @@ class Dsymbol;
class Expression;
class FuncDeclaration;
class Parameter;
+class Statement;
class Type;
class TypeFunction;
class TypeTuple;
@@ -30,6 +31,7 @@ struct TargetC
{
unsigned longsize; // size of a C 'long' or 'unsigned long' type
unsigned long_doublesize; // size of a C 'long double'
+ Type *twchar_t; // C 'wchar_t' type
};
struct TargetCPP
@@ -44,6 +46,7 @@ struct TargetCPP
const char *typeMangle(Type *t);
Type *parameterType(Parameter *p);
bool fundamentalType(const Type *t, bool& isFundamental);
+ unsigned derivedClassOffset(ClassDeclaration *baseClass);
};
struct TargetObjC
@@ -108,6 +111,7 @@ public:
TypeTuple *toArgTypes(Type *t);
bool isReturnOnStack(TypeFunction *tf, bool needsThis);
Expression *getTargetInfo(const char* name, const Loc& loc);
+ bool libraryObjectMonitors(FuncDeclaration *fd, Statement *fbody);
};
extern Target target;
@@ -78,6 +78,7 @@ public:
bool ismixin; // template declaration is only to be used as a mixin
bool isstatic; // this is static template declaration
Prot protection;
+ int inuse; // for recursive expansion detection
TemplatePrevious *previous; // threaded list of previous instantiation attempts on stack
@@ -25,7 +25,7 @@ public:
{
this->sc = sc;
this->parameters = parameters;
- this->result = false;
+ this->result = false;
}
void visit(TemplateTypeParameter *ttp)
@@ -40,6 +40,8 @@ void freeFieldinit(Scope *sc);
Expression *resolve(Loc loc, Scope *sc, Dsymbol *s, bool hasOverloads);
Package *resolveIsPackage(Dsymbol *sym);
Expression *typeToExpression(Type *t);
+Type *decoToType(const char *deco);
+bool expressionsToString(OutBuffer &buf, Scope *sc, Expressions *exps);
/************************************************
@@ -442,7 +444,6 @@ TraitsInitializer::TraitsInitializer()
"derivedMembers",
"isSame",
"compiles",
- "parameters",
"getAliasThis",
"getAttributes",
"getFunctionAttributes",
@@ -1032,6 +1033,34 @@ Expression *semanticTraits(TraitsExp *e, Scope *sc)
ex = expressionSemantic(ex, sc);
return ex;
}
+ else if (e->ident == Id::toType)
+ {
+ if (dim != 1)
+ return dimError(e, 1, dim);
+
+ Expression *ex = isExpression((*e->args)[0]);
+ if (!ex)
+ {
+ e->error("expression expected as second argument of __traits `%s`", e->ident->toChars());
+ return new ErrorExp();
+ }
+ ex = ex->ctfeInterpret();
+
+ StringExp *se = semanticString(sc, ex, "__traits(toType, string)");
+ if (!se)
+ {
+ return new ErrorExp();
+ }
+ Type *t = decoToType(se->toUTF8(sc)->toPtr());
+ if (!t)
+ {
+ e->error("cannot determine `%s`", e->toChars());
+ return new ErrorExp();
+ }
+ ex = new TypeExp(e->loc, t);
+ ex = expressionSemantic(ex, sc);
+ return ex;
+ }
else if (e->ident == Id::hasMember ||
e->ident == Id::getMember ||
e->ident == Id::getOverloads ||
@@ -1674,33 +1703,67 @@ Expression *semanticTraits(TraitsExp *e, Scope *sc)
RootObject *o = (*e->args)[i];
Type *t = isType(o);
- Expression *ex = t ? typeToExpression(t) : isExpression(o);
- if (!ex && t)
+ while (t)
{
- Dsymbol *s;
- t->resolve(e->loc, sc2, &ex, &t, &s);
- if (t)
+ if (TypeMixin *tm = t->isTypeMixin())
{
- typeSemantic(t, e->loc, sc2);
- if (t->ty == Terror)
+ /* The mixin string could be a type or an expression.
+ * Have to try compiling it to see.
+ */
+ OutBuffer buf;
+ if (expressionsToString(buf, sc, tm->exps))
+ {
+ err = true;
+ break;
+ }
+ const size_t len = buf.length();
+ const char *str = buf.extractChars();
+ Parser p(e->loc, sc->_module, (const utf8_t *)str, len, false);
+ p.nextToken();
+ //printf("p.loc.linnum = %d\n", p.loc.linnum);
+
+ o = p.parseTypeOrAssignExp(TOKeof);
+ if (p.errors || p.token.value != TOKeof)
+ {
err = true;
+ break;
+ }
+ t = isType(o);
}
- else if (s && s->errors)
- err = true;
+ else
+ break;
}
- if (ex)
+
+ if (!err)
{
- ex = expressionSemantic(ex, sc2);
- ex = resolvePropertiesOnly(sc2, ex);
- ex = ex->optimize(WANTvalue);
- if (sc2->func && sc2->func->type->ty == Tfunction)
+ Expression *ex = t ? typeToExpression(t) : isExpression(o);
+ if (!ex && t)
{
- TypeFunction *tf = (TypeFunction *)sc2->func->type;
- canThrow(ex, sc2->func, tf->isnothrow);
+ Dsymbol *s;
+ t->resolve(e->loc, sc2, &ex, &t, &s);
+ if (t)
+ {
+ typeSemantic(t, e->loc, sc2);
+ if (t->ty == Terror)
+ err = true;
+ }
+ else if (s && s->errors)
+ err = true;
+ }
+ if (ex)
+ {
+ ex = expressionSemantic(ex, sc2);
+ ex = resolvePropertiesOnly(sc2, ex);
+ ex = ex->optimize(WANTvalue);
+ if (sc2->func && sc2->func->type->ty == Tfunction)
+ {
+ TypeFunction *tf = (TypeFunction *)sc2->func->type;
+ canThrow(ex, sc2->func, tf->isnothrow);
+ }
+ ex = checkGC(sc2, ex);
+ if (ex->op == TOKerror)
+ err = true;
}
- ex = checkGC(sc2, ex);
- if (ex->op == TOKerror)
- err = true;
}
// Carefully detach the scope from the parent and throw it away as
@@ -18,6 +18,7 @@
#include "hdrgen.h"
#include "id.h"
#include "init.h"
+#include "parse.h"
#include "scope.h"
#include "target.h"
#include "template.h"
@@ -25,6 +26,7 @@
Expression *typeToExpression(Type *t);
Expression *typeToExpressionHelper(TypeQualified *t, Expression *e, size_t i = 0);
+bool expressionsToString(OutBuffer &buf, Scope *sc, Expressions *exps);
char *MODtoChars(MOD mod);
class TypeToExpressionVisitor : public Visitor
@@ -76,6 +78,11 @@ public:
{
result = typeToExpressionHelper(t, new ScopeExp(t->loc, t->tempinst));
}
+
+ void visit(TypeMixin *t)
+ {
+ result = new TypeExp(t->loc, t);
+ }
};
/* We've mistakenly parsed this as a type.
@@ -84,6 +91,8 @@ public:
*/
Expression *typeToExpression(Type *t)
{
+ if (t->mod)
+ return NULL;
TypeToExpressionVisitor v = TypeToExpressionVisitor(t);
t->accept(&v);
return v.result;
@@ -177,6 +186,48 @@ static Expression *semanticLength(Scope *sc, TupleDeclaration *s, Expression *ex
return exp;
}
+/******************************************
+ * 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 unsigned errors = global.errors;
+ const size_t len = buf.length();
+ const char *str = buf.extractChars();
+ Parser p(loc, sc->_module, (const utf8_t *)str, len, false);
+ p.nextToken();
+ //printf("p.loc.linnum = %d\n", p.loc.linnum);
+
+ RootObject *o = p.parseTypeOrAssignExp(TOKeof);
+ if (errors != global.errors)
+ {
+ assert(global.errors != errors); // should have caught all these cases
+ return NULL;
+ }
+ if (p.token.value != TOKeof)
+ {
+ ::error(loc, "incomplete mixin type `%s`", str);
+ return NULL;
+ }
+
+ Type *t = isType(o);
+ Expression *e = t ? typeToExpression(t) : isExpression(o);
+
+ return (!e && t) ? (RootObject *)t : (RootObject *)e;
+}
+
/******************************************
* Perform semantic analysis on a type.
* Params:
@@ -440,7 +491,7 @@ Type *typeSemantic(Type *type, const Loc &loc, Scope *sc)
// 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 == Ttypeof || mtype->index->ty == Treturn || mtype->index->ty == Tmixin)
{
Expression *e;
Type *t;
@@ -1072,6 +1123,7 @@ Type *typeSemantic(Type *type, const Loc &loc, Scope *sc)
mtype->exp->ident != Id::getMember &&
mtype->exp->ident != Id::parent &&
mtype->exp->ident != Id::child &&
+ mtype->exp->ident != Id::toType &&
mtype->exp->ident != Id::getOverloads &&
mtype->exp->ident != Id::getVirtualFunctions &&
mtype->exp->ident != Id::getVirtualMethods &&
@@ -1275,7 +1327,7 @@ Type *typeSemantic(Type *type, const Loc &loc, Scope *sc)
void visit(TypeStruct *mtype)
{
- //printf("TypeStruct::semantic('%s')\n", mtype->sym->toChars());
+ //printf("TypeStruct::semantic('%s')\n", mtype->toChars());
if (mtype->deco)
{
if (sc && sc->cppmangle != CPPMANGLEdefault)
@@ -1304,7 +1356,7 @@ Type *typeSemantic(Type *type, const Loc &loc, Scope *sc)
void visit(TypeClass *mtype)
{
- //printf("TypeClass::semantic(%s)\n", mtype->sym->toChars());
+ //printf("TypeClass::semantic(%s)\n", mtype->toChars());
if (mtype->deco)
{
if (sc && sc->cppmangle != CPPMANGLEdefault)
@@ -1386,6 +1438,25 @@ Type *typeSemantic(Type *type, const Loc &loc, Scope *sc)
Type *t = new TypeTuple(args);
result = typeSemantic(t, loc, sc);
}
+
+ void visit(TypeMixin *mtype)
+ {
+ //printf("TypeMixin::semantic() %s\n", mtype->toChars());
+
+ Expression *e = NULL;
+ Type *t = NULL;
+ Dsymbol *s = NULL;
+ mtype->resolve(loc, sc, &e, &t, &s);
+
+ if (t && t->ty != Terror)
+ {
+ result = t;
+ return;
+ }
+
+ ::error(mtype->loc, "`mixin(%s)` does not give a valid type", mtype->obj->toChars());
+ return error();
+ }
};
TypeSemanticVisitor v(loc, sc);
type->accept(&v);
@@ -81,7 +81,9 @@ class TypeClass;
class TypeTuple;
class TypeSlice;
class TypeNull;
+class TypeNoreturn;
class TypeTraits;
+class TypeMixin;
class Dsymbol;
@@ -374,7 +376,9 @@ public:
virtual void visit(TypeTuple *t) { visit((Type *)t); }
virtual void visit(TypeSlice *t) { visit((TypeNext *)t); }
virtual void visit(TypeNull *t) { visit((Type *)t); }
+ virtual void visit(TypeNoreturn *t) { visit((Type *)t); }
virtual void visit(TypeTraits *t) { visit((Type *)t); }
+ virtual void visit(TypeMixin *t) { visit((Type *)t); }
virtual void visit(Dsymbol *) { assert(0); }
@@ -1068,6 +1068,13 @@ public:
add_stmt (return_expr (decl));
}
+ else if (tf->next->ty == Tnoreturn)
+ {
+ /* Returning an expression that has no value, but has a side effect
+ that should never return. */
+ add_stmt (build_expr_dtor (s->exp));
+ add_stmt (return_expr (NULL_TREE));
+ }
else
{
/* Convert for initializing the DECL_RESULT. */
@@ -603,6 +603,12 @@ public:
t->ctype = ptr_type_node;
}
+ /* Bottom type used for functions that never return. */
+
+ void visit (TypeNoreturn *t)
+ {
+ t->ctype = void_type_node;
+ }
/* Basic Data Types. */
@@ -852,7 +858,46 @@ public:
tree basetype = (t->sym->memtype)
? build_ctype (t->sym->memtype) : void_type_node;
- if (!INTEGRAL_TYPE_P (basetype) || TREE_CODE (basetype) == BOOLEAN_TYPE)
+ if (t->sym->isSpecial ())
+ {
+ /* Special enums are opaque types that bind to C types. */
+ const char *ident = t->toChars ();
+ Type *underlying = NULL;
+
+ /* Skip over the prefixing `__c_'. */
+ gcc_assert (strncmp (ident, "__c_", strlen ("__c_")) == 0);
+ ident = ident + strlen ("__c_");
+
+ /* To keep things compatible within the code generation we stick to
+ mapping to equivalent D types. However it should be OK to use the
+ GCC provided C types here as the front-end enforces that everything
+ must be explicitly cast from a D type to any of the opaque types. */
+ if (strcmp (ident, "long") == 0)
+ underlying = build_frontend_type (long_integer_type_node);
+ else if (strcmp (ident, "ulong") == 0)
+ underlying = build_frontend_type (long_unsigned_type_node);
+ else if (strcmp (ident, "wchar_t") == 0)
+ underlying = target.c.twchar_t;
+ else if (strcmp (ident, "longlong") == 0)
+ underlying = build_frontend_type (long_long_integer_type_node);
+ else if (strcmp (ident, "ulonglong") == 0)
+ underlying = build_frontend_type (long_long_unsigned_type_node);
+ else if (strcmp (ident, "long_double") == 0)
+ underlying = build_frontend_type (long_double_type_node);
+ else if (strcmp (ident, "complex_real") == 0)
+ underlying = build_frontend_type (complex_long_double_type_node);
+ else if (strcmp (ident, "complex_float") == 0)
+ underlying = build_frontend_type (complex_float_type_node);
+ else if (strcmp (ident, "complex_double") == 0)
+ underlying = build_frontend_type (complex_double_type_node);
+
+ /* Conversion failed or there's an unhandled special type. */
+ gcc_assert (underlying != NULL);
+
+ t->ctype = build_variant_type_copy (build_ctype (underlying));
+ build_type_decl (t->ctype, t->sym);
+ }
+ else if (!INTEGRAL_TYPE_P (basetype) || TREE_CODE (basetype) == BOOLEAN_TYPE)
{
/* Enums in D2 can have a base type that is not necessarily integral.
For these, we simplify this a little by using the base type directly