mv findVtblIndex() and overrideInterface() to funcsem.d (#16127)

compiler/src/dmd/cppmanglewin.d

@@ -25,6 +25,7 @@ import dmd.dtemplate;
 import dmd.errors;
 import dmd.expression;
 import dmd.func;
+import dmd.funcsem;
 import dmd.globals;
 import dmd.id;
 import dmd.identifier;
@@ -513,7 +514,7 @@ extern(D):
  // Pivate methods always non-virtual in D and it should be mangled as non-virtual in C++
  //printf("%s: isVirtualMethod = %d, isVirtual = %d, vtblIndex = %d, interfaceVirtual = %p\n",
  //d.toChars(), d.isVirtualMethod(), d.isVirtual(), cast(int)d.vtblIndex, d.interfaceVirtual);
- if ((d.isVirtual() && (d.vtblIndex != -1 || d.interfaceVirtual || d.overrideInterface())) || (d.isDtorDeclaration() && d.parent.isClassDeclaration() && !d.isFinal()))
+ if ((d.isVirtual() && (d.vtblIndex != -1 || d.interfaceVirtual || overrideInterface(d))) || (d.isDtorDeclaration() && d.parent.isClassDeclaration() && !d.isFinal()))
  {
  mangleVisibility(buf, d, "EMU");
  }

compiler/src/dmd/declaration.h

@@ -703,7 +703,6 @@ class FuncDeclaration : public Declaration
  Expressions *fdensureParams(Expressions *fdep);
  bool equals(const RootObject * const o) const override final;
 
- int findVtblIndex(Dsymbols *vtbl, int dim);
  bool overloadInsert(Dsymbol *s) override;
  bool inUnittest();
  static MATCH leastAsSpecialized(FuncDeclaration *f, FuncDeclaration *g, Identifiers *names);

compiler/src/dmd/expressionsem.d

@@ -6290,7 +6290,7 @@ private extern (C++) final class ExpressionSemanticVisitor : Visitor
  auto ad2 = b.sym;
  ue.e1 = ue.e1.castTo(sc, ad2.type.addMod(ue.e1.type.mod));
  ue.e1 = ue.e1.expressionSemantic(sc);
- auto vi = exp.f.findVtblIndex(&ad2.vtbl, cast(int)ad2.vtbl.length);
+ auto vi = findVtblIndex(exp.f, ad2.vtbl[]);
  assert(vi >= 0);
  exp.f = ad2.vtbl[vi].isFuncDeclaration();
  assert(exp.f);

compiler/src/dmd/frontend.h

@@ -3793,7 +3793,6 @@ class FuncDeclaration : public Declaration
  Array<Expression* >* fdensureParams(Array<Expression* >* param);
  FuncDeclaration* syntaxCopy(Dsymbol* s) override;
  bool equals(const RootObject* const o) const final override;
- int32_t findVtblIndex(Array<Dsymbol* >* vtbl, int32_t dim);
  bool overloadInsert(Dsymbol* s) override;
  bool inUnittest();
  static MATCH leastAsSpecialized(FuncDeclaration* f, FuncDeclaration* g, Array<Identifier* >* names);

compiler/src/dmd/func.d

@@ -531,154 +531,6 @@ extern (C++) class FuncDeclaration : Declaration
  return result;
  }
 
- /*************************************************
- * Find index of function in vtbl[0..length] that
- * this function overrides.
- * Prefer an exact match to a covariant one.
- * Params:
- * vtbl = vtable to use
- * dim = maximal vtable dimension
- * Returns:
- * -1 didn't find one
- * -2 can't determine because of forward references
- */
- final int findVtblIndex(Dsymbols* vtbl, int dim)
- {
- //printf("findVtblIndex() %s\n", toChars());
- import dmd.typesem : covariant;
-
- FuncDeclaration mismatch = null;
- StorageClass mismatchstc = 0;
- int mismatchvi = -1;
- int exactvi = -1;
- int bestvi = -1;
- for (int vi = 0; vi < dim; vi++)
- {
- FuncDeclaration fdv = (*vtbl)[vi].isFuncDeclaration();
- if (fdv && fdv.ident == ident)
- {
- if (type.equals(fdv.type)) // if exact match
- {
- if (fdv.parent.isClassDeclaration())
- {
- if (fdv.isFuture())
- {
- bestvi = vi;
- continue; // keep looking
- }
- return vi; // no need to look further
- }
-
- if (exactvi >= 0)
- {
- .error(loc, "%s `%s` cannot determine overridden function", kind, toPrettyChars);
- return exactvi;
- }
- exactvi = vi;
- bestvi = vi;
- continue;
- }
-
- StorageClass stc = 0;
- const cov = type.covariant(fdv.type, &stc);
- //printf("\tbaseclass cov = %d\n", cov);
- final switch (cov)
- {
- case Covariant.distinct:
- // types are distinct
- break;
-
- case Covariant.yes:
- bestvi = vi; // covariant, but not identical
- break;
- // keep looking for an exact match
-
- case Covariant.no:
- mismatchvi = vi;
- mismatchstc = stc;
- mismatch = fdv; // overrides, but is not covariant
- break;
- // keep looking for an exact match
-
- case Covariant.fwdref:
- return -2; // forward references
- }
- }
- }
- if (_linkage == LINK.cpp && bestvi != -1)
- {
- StorageClass stc = 0;
- FuncDeclaration fdv = (*vtbl)[bestvi].isFuncDeclaration();
- assert(fdv && fdv.ident == ident);
- if (type.covariant(fdv.type, &stc, /*cppCovariant=*/true) == Covariant.no)
- {
- /* https://issues.dlang.org/show_bug.cgi?id=22351
- * Under D rules, `type` and `fdv.type` are covariant, but under C++ rules, they are not.
- * For now, continue to allow D covariant rules to apply when `override` has been used,
- * but issue a deprecation warning that this behaviour will change in the future.
- * Otherwise, follow the C++ covariant rules, which will create a new vtable entry.
- */
- if (isOverride())
- {
- /* @@@DEPRECATED_2.110@@@
- * After deprecation period has ended, be sure to remove this entire `LINK.cpp` branch,
- * but also the `cppCovariant` parameter from Type.covariant, and update the function
- * so that both `LINK.cpp` covariant conditions within are always checked.
- */
- .deprecation(loc, "overriding `extern(C++)` function `%s%s` with `const` qualified function `%s%s%s` is deprecated",
- fdv.toPrettyChars(), fdv.type.toTypeFunction().parameterList.parametersTypeToChars(),
- toPrettyChars(), type.toTypeFunction().parameterList.parametersTypeToChars(), type.modToChars());
-
- const char* where = type.isNaked() ? "parameters" : "type";
- deprecationSupplemental(loc, "Either remove `override`, or adjust the `const` qualifiers of the "
- ~ "overriding function %s", where);
- }
- else
- {
- // Treat as if Covariant.no
- mismatchvi = bestvi;
- mismatchstc = stc;
- mismatch = fdv;
- bestvi = -1;
- }
- }
- }
- if (bestvi == -1 && mismatch)
- {
- //type.print();
- //mismatch.type.print();
- //printf("%s %s\n", type.deco, mismatch.type.deco);
- //printf("stc = %llx\n", mismatchstc);
- if (mismatchstc)
- {
- // Fix it by modifying the type to add the storage classes
- type = type.addStorageClass(mismatchstc);
- bestvi = mismatchvi;
- }
- }
- return bestvi;
- }
-
- /*********************************
- * If function a function in a base class,
- * return that base class.
- * Returns:
- * base class if overriding, null if not
- */
- extern (D) final BaseClass* overrideInterface()
- {
- for (ClassDeclaration cd = toParent2().isClassDeclaration(); cd; cd = cd.baseClass)
- {
- foreach (b; cd.interfaces)
- {
- auto v = findVtblIndex(&b.sym.vtbl, cast(int)b.sym.vtbl.length);
- if (v >= 0)
- return b;
- }
- }
- return null;
- }
-
  /****************************************************
  * Overload this FuncDeclaration with the new one f.
  * Return true if successful; i.e. no conflict.

compiler/src/dmd/funcsem.d

@@ -502,7 +502,7 @@ void funcDeclarationSemantic(Scope* sc, FuncDeclaration funcdecl)
  /* Find index of existing function in base class's vtbl[] to override
  * (the index will be the same as in cd's current vtbl[])
  */
- int vi = cd.baseClass ? funcdecl.findVtblIndex(&cd.baseClass.vtbl, cast(int)cd.baseClass.vtbl.length) : -1;
+ int vi = cd.baseClass ? findVtblIndex(funcdecl, cd.baseClass.vtbl[]) : -1;
 
  bool doesoverride = false;
  switch (vi)
@@ -539,7 +539,7 @@ void funcDeclarationSemantic(Scope* sc, FuncDeclaration funcdecl)
  /* if overriding an interface function, then this is not
  * introducing and don't put it in the class vtbl[]
  */
- funcdecl.interfaceVirtual = funcdecl.overrideInterface();
+ funcdecl.interfaceVirtual = overrideInterface(funcdecl);
  if (funcdecl.interfaceVirtual)
  {
  //printf("\tinterface function %s\n", toChars());
@@ -764,7 +764,7 @@ void funcDeclarationSemantic(Scope* sc, FuncDeclaration funcdecl)
  {
  foreach (b; bcd.interfaces)
  {
- vi = funcdecl.findVtblIndex(&b.sym.vtbl, cast(int)b.sym.vtbl.length);
+ vi = findVtblIndex(funcdecl, b.sym.vtbl[]);
  switch (vi)
  {
  case -1:
@@ -1217,3 +1217,153 @@ extern (D) bool checkForwardRef(FuncDeclaration fd, const ref Loc loc)
  }
  return false;
 }
+
+/*************************************************
+ * Find index of function in vtbl[0..length] that
+ * this function overrides.
+ * Prefer an exact match to a covariant one.
+ * Params:
+ * fd = function
+ * vtbl = vtable to use
+ * Returns:
+ * -1 didn't find one
+ * -2 can't determine because of forward references
+ */
+int findVtblIndex(FuncDeclaration fd, Dsymbol[] vtbl)
+{
+ //printf("findVtblIndex() %s\n", toChars());
+ import dmd.typesem : covariant;
+
+ FuncDeclaration mismatch = null;
+ StorageClass mismatchstc = 0;
+ int mismatchvi = -1;
+ int exactvi = -1;
+ int bestvi = -1;
+ for (int vi = 0; vi < cast(int)vtbl.length; vi++)
+ {
+ FuncDeclaration fdv = vtbl[vi].isFuncDeclaration();
+ if (fdv && fdv.ident == fd.ident)
+ {
+ if (fd.type.equals(fdv.type)) // if exact match
+ {
+ if (fdv.parent.isClassDeclaration())
+ {
+ if (fdv.isFuture())
+ {
+ bestvi = vi;
+ continue; // keep looking
+ }
+ return vi; // no need to look further
+ }
+
+ if (exactvi >= 0)
+ {
+ .error(fd.loc, "%s `%s` cannot determine overridden function", fd.kind, fd.toPrettyChars);
+ return exactvi;
+ }
+ exactvi = vi;
+ bestvi = vi;
+ continue;
+ }
+
+ StorageClass stc = 0;
+ const cov = fd.type.covariant(fdv.type, &stc);
+ //printf("\tbaseclass cov = %d\n", cov);
+ final switch (cov)
+ {
+ case Covariant.distinct:
+ // types are distinct
+ break;
+
+ case Covariant.yes:
+ bestvi = vi; // covariant, but not identical
+ break;
+ // keep looking for an exact match
+
+ case Covariant.no:
+ mismatchvi = vi;
+ mismatchstc = stc;
+ mismatch = fdv; // overrides, but is not covariant
+ break;
+ // keep looking for an exact match
+
+ case Covariant.fwdref:
+ return -2; // forward references
+ }
+ }
+ }
+ if (fd._linkage == LINK.cpp && bestvi != -1)
+ {
+ StorageClass stc = 0;
+ FuncDeclaration fdv = vtbl[bestvi].isFuncDeclaration();
+ assert(fdv && fdv.ident == fd.ident);
+ if (fd.type.covariant(fdv.type, &stc, /*cppCovariant=*/true) == Covariant.no)
+ {
+ /* https://issues.dlang.org/show_bug.cgi?id=22351
+ * Under D rules, `type` and `fdv.type` are covariant, but under C++ rules, they are not.
+ * For now, continue to allow D covariant rules to apply when `override` has been used,
+ * but issue a deprecation warning that this behaviour will change in the future.
+ * Otherwise, follow the C++ covariant rules, which will create a new vtable entry.
+ */
+ if (fd.isOverride())
+ {
+ /* @@@DEPRECATED_2.110@@@
+ * After deprecation period has ended, be sure to remove this entire `LINK.cpp` branch,
+ * but also the `cppCovariant` parameter from Type.covariant, and update the function
+ * so that both `LINK.cpp` covariant conditions within are always checked.
+ */
+ .deprecation(fd.loc, "overriding `extern(C++)` function `%s%s` with `const` qualified function `%s%s%s` is deprecated",
+ fdv.toPrettyChars(), fdv.type.toTypeFunction().parameterList.parametersTypeToChars(),
+ fd.toPrettyChars(), fd.type.toTypeFunction().parameterList.parametersTypeToChars(), fd.type.modToChars());
+
+ const char* where = fd.type.isNaked() ? "parameters" : "type";
+ deprecationSupplemental(fd.loc, "Either remove `override`, or adjust the `const` qualifiers of the "
+ ~ "overriding function %s", where);
+ }
+ else
+ {
+ // Treat as if Covariant.no
+ mismatchvi = bestvi;
+ mismatchstc = stc;
+ mismatch = fdv;
+ bestvi = -1;
+ }
+ }
+ }
+ if (bestvi == -1 && mismatch)
+ {
+ //type.print();
+ //mismatch.type.print();
+ //printf("%s %s\n", type.deco, mismatch.type.deco);
+ //printf("stc = %llx\n", mismatchstc);
+ if (mismatchstc)
+ {
+ // Fix it by modifying the type to add the storage classes
+ fd.type = fd.type.addStorageClass(mismatchstc);
+ bestvi = mismatchvi;
+ }
+ }
+ return bestvi;
+}
+
+/*********************************
+ * If function is a function in a base class,
+ * return that base class.
+ * Params:
+ * fd = function
+ * Returns:
+ * base class if overriding, null if not
+ */
+BaseClass* overrideInterface(FuncDeclaration fd)
+{
+ for (ClassDeclaration cd = fd.toParent2().isClassDeclaration(); cd; cd = cd.baseClass)
+ {
+ foreach (b; cd.interfaces)
+ {
+ auto v = findVtblIndex(fd, b.sym.vtbl[]);
+ if (v >= 0)
+ return b;
+ }
+ }
+ return null;
+}