[mtype.d] move numberOfElems and checkRetType to typesem.d

compiler/src/dmd/frontend.h

@@ -1878,7 +1878,6 @@ class Type : public ASTNode
  virtual bool hasInvariant();
  virtual Type* nextOf();
  Type* baseElemOf();
- uint32_t numberOfElems(const Loc& loc);
  virtual bool needsDestruction();
  virtual bool needsCopyOrPostblit();
  virtual bool needsNested();

compiler/src/dmd/mtype.d

@@ -1398,33 +1398,6 @@ extern (C++) abstract class Type : ASTNode
  return t;
  }
 
- /*******************************************
- * Compute number of elements for a (possibly multidimensional) static array,
- * or 1 for other types.
- * Params:
- * loc = for error message
- * Returns:
- * number of elements, uint.max on overflow
- */
- final uint numberOfElems(const ref Loc loc)
- {
- //printf("Type::numberOfElems()\n");
- uinteger_t n = 1;
- Type tb = this;
- while ((tb = tb.toBasetype()).ty == Tsarray)
- {
- bool overflow = false;
- n = mulu(n, (cast(TypeSArray)tb).dim.toUInteger(), overflow);
- if (overflow || n >= uint.max)
- {
- error(loc, "static array `%s` size overflowed to %llu", toChars(), cast(ulong)n);
- return uint.max;
- }
- tb = (cast(TypeSArray)tb).next;
- }
- return cast(uint)n;
- }
-
  /****************************************
  * Return the mask that an integral type will
  * fit into.
@@ -2724,36 +2697,6 @@ extern (C++) final class TypeFunction : TypeNext
  return newArgs;
  }
 
- extern (D) bool checkRetType(const ref Loc loc)
- {
- Type tb = next.toBasetype();
- if (tb.ty == Tfunction)
- {
- error(loc, "functions cannot return a function");
- next = Type.terror;
- }
- if (tb.ty == Ttuple)
- {
- error(loc, "functions cannot return a sequence (use `std.typecons.Tuple`)");
- next = Type.terror;
- }
- if (!isRef && (tb.ty == Tstruct || tb.ty == Tsarray))
- {
- if (auto ts = tb.baseElemOf().isTypeStruct())
- {
- if (!ts.sym.members)
- {
- error(loc, "functions cannot return opaque type `%s` by value", tb.toChars());
- next = Type.terror;
- }
- }
- }
- if (tb.ty == Terror)
- return true;
- return false;
- }
-
-
  /// Returns: `true` the function is `isInOutQual` or `isInOutParam` ,`false` otherwise.
  bool iswild() const pure nothrow @safe @nogc
  {

compiler/src/dmd/typesem.d

@@ -7479,6 +7479,62 @@ MATCH implicitConvToThroughAliasThis(TypeStruct from, Type to)
  return MATCH.nomatch;
 }
 
+/*******************************************
+ * Compute number of elements for a (possibly multidimensional) static array,
+ * or 1 for other types.
+ * Params:
+ * t = static array type
+ * loc = for error message
+ * Returns:
+ * number of elements, uint.max on overflow
+ */
+uint numberOfElems(Type t, const ref Loc loc)
+{
+ //printf("Type::numberOfElems()\n");
+ uinteger_t n = 1;
+ Type tb = t;
+ while ((tb = tb.toBasetype()).ty == Tsarray)
+ {
+ bool overflow = false;
+ n = mulu(n, (cast(TypeSArray)tb).dim.toUInteger(), overflow);
+ if (overflow || n >= uint.max)
+ {
+ error(loc, "static array `%s` size overflowed to %llu", t.toChars(), cast(ulong)n);
+ return uint.max;
+ }
+ tb = (cast(TypeSArray)tb).next;
+ }
+ return cast(uint)n;
+}
+
+bool checkRetType(TypeFunction tf, const ref Loc loc)
+{
+ Type tb = tf.next.toBasetype();
+ if (tb.ty == Tfunction)
+ {
+ error(loc, "functions cannot return a function");
+ tf.next = Type.terror;
+ }
+ if (tb.ty == Ttuple)
+ {
+ error(loc, "functions cannot return a sequence (use `std.typecons.Tuple`)");
+ tf.next = Type.terror;
+ }
+ if (!tf.isRef && (tb.ty == Tstruct || tb.ty == Tsarray))
+ {
+ if (auto ts = tb.baseElemOf().isTypeStruct())
+ {
+ if (!ts.sym.members)
+ {
+ error(loc, "functions cannot return opaque type `%s` by value", tb.toChars());
+ tf.next = Type.terror;
+ }
+ }
+ }
+ if (tb.ty == Terror)
+ return true;
+ return false;
+}
 
 
 /******************************* Private *****************************************/