[flang] Resolve USE vs IMPORT conflicts

[klausler]

Summary

When the same name is pulled into a scope more than once via
USE and IMPORT, emit an error if its resolutions are ambiguous,
or (as an extension like some other compilers) emit a portability
warning when the names all resolve to the same symbol.

[PeteSteinfeld]

All builds and tests correctly and looks good.

flang/docs/Extensions.md

* A `NOPASS` type-bound procedure binding is required by C1529
   implementation.
 * A label may follow a semicolon in fixed form source.
 * A scalar logical dummy argument to a `BIND(C)` procedure does
   not have to have `KIND=C_BOOL` since it can be converted to/from
   `_Bool` without loss of information.
 * The character length of the `SOURCE=` or `MOLD=` in `ALLOCATE`
   may be distinct from the constant character length, if any,
   of an allocated object.
+* When a name is brought into a scope by multiple ways,
+  such as USE-association as well as an `IMPORT` from its host,
+  it's an error only if the resolution is ambiguous.
 
 ### Extensions supported when enabled by options
 
 * C-style backslash escape sequences in quoted CHARACTER literals
   (but not Hollerith) [-fbackslash]
 * Logical abbreviations `.T.`, `.F.`, `.N.`, `.A.`, `.O.`, and `.X.`
   [-flogical-abbreviations]
 * `.XOR.` as a synonym for `.NEQV.` [-fxor-operator]

flang/lib/Semantics/resolve-names.cpp

case Scope::Kind::BlockData: // C1415 (in part)
     Say("IMPORT is not allowed in a BLOCK DATA subprogram"_err_en_US);
     return false;
   default:;
   }
   if (auto error{scope.SetImportKind(x.kind)}) {
     Say(std::move(*error));
   }
   for (auto &name : x.names) {
-    if (FindSymbol(scope.parent(), name)) {
+    if (Symbol * outer{FindSymbol(scope.parent(), name)}) {
       scope.add_importName(name.source);
+      if (Symbol * symbol{FindInScope(name)}) {
+        if (outer->GetUltimate() == symbol->GetUltimate()) {
+          Say(name,
+              "The same '%s' is already present in this scope"_port_en_US);
+        } else {
+          Say(name,
+              "A distinct '%s' is already present in this scope"_err_en_US)
+              .Attach(symbol->name(), "Previous declaration of '%s'"_en_US)
+              .Attach(outer->name(), "Declaration of '%s' in host scope"_en_US);
+        }
+      }
     } else {
       Say(name, "'%s' not found in host scope"_err_en_US);
     }
   }
   prevImportStmt_ = currStmtSource();
   return false;
 }
 

flang/test/Semantics/resolve118.f90

+! RUN: %python %S/test_errors.py %s %flang_fc1
+! USE vs IMPORT
+module m1
+  type t
+    integer n
+  end type
+end module
+
+module m2
+  type t
+    real x
+  end type
+end module
+
+module m3
+  use m1
+  interface
+    subroutine s1(x)
+      use m1
+      !PORTABILITY: The same 't' is already present in this scope
+      import t
+      type(t) x
+    end
+    subroutine s2(x)
+      use m2
+      !ERROR: A distinct 't' is already present in this scope
+      import t
+      type(t) x
+    end
+  end interface
+end module
+
+module m4
+  type t
+    complex z
+  end type
+  interface
+    subroutine s3(x)
+      use m1
+      !ERROR: A distinct 't' is already present in this scope
+      import t
+      type(t) x
+    end
+  end interface
+end module
+
+module m5
+  interface
+    subroutine s4(x)
+      use m1
+      !ERROR: A distinct 't' is already present in this scope
+      import t
+      type(t) x
+    end
+  end interface
+ contains
+  subroutine t
+  end
+end module