simplify use/import shadowing

compiler/AST/UseStmt.cpp

@@ -150,6 +150,19 @@ bool UseStmt::hasOnlyList() const {
   return isPlainUse() == false && except == false;
 }
 
+bool UseStmt::hasOnlyNothing() const {
+  if (hasOnlyList()) {
+    if (renamed.size() == 0) {
+      // check for named being empty or containing the empty string
+      if (named.size() == 0 ||
+          (named.size() == 1 && named[0][0] == '\0'))
+        return true;
+    }
+  }
+
+  return false;
+}
+
 bool UseStmt::hasExceptList() const {
   return isPlainUse() == false && except == true;
 }

compiler/AST/baseAST.cpp

@@ -242,13 +242,6 @@ void cleanAst() {
     serializeMap.erase(key);
   }
 
-  // Important: Sometimes scopeResolve will create dummy UseStmts that are
-  // never inserted into the tree, and will be deleted in between passes.
-  //
-  // If we do not destroy the caches, they may contain pointers back to these
-  // dummy uses.
-  destroyModuleUsesCaches();
-
   //
   // clear back pointers to dead ast instances
   //

compiler/include/UseStmt.h

@@ -53,6 +53,8 @@ class UseStmt final : public VisibilityStmt {
 
   bool            hasOnlyList()                                          const;
 
+  bool            hasOnlyNothing()                                       const;
+
   bool            hasExceptList()                                        const;
 
   void            scopeResolve(ResolveScope* scope);

compiler/include/resolution.h

@@ -224,7 +224,7 @@ void explainAndCheckInstantiation(FnSymbol* newFn, FnSymbol* fn);
 
 class DisambiguationContext {
 public:
-                 DisambiguationContext(CallInfo& info);
+                 DisambiguationContext(CallInfo& info, BlockStmt* searchScope);
 
   Vec<Symbol*>*  actuals;
   Expr*          scope;

compiler/include/scopeResolve.h

@@ -65,6 +65,4 @@ BaseAST* getScope(BaseAST* ast);
 void resolveUnresolvedSymExprs(BaseAST* ast);
 void resolveUnmanagedBorrows(CallExpr* call);
 
-void destroyModuleUsesCaches();
-
 #endif

compiler/passes/checkParsed.cpp

@@ -47,6 +47,7 @@ static void setupForCheckExplicitDeinitCalls();
 static void warnUnstableUnions(AggregateType* at);
 static void warnUnstableLeadingUnderscores();
 static void checkOperator(FnSymbol* fn);
+static void checkUseStmt(UseStmt* use);
 
 void
 checkParsed() {
@@ -119,6 +120,10 @@ checkParsed() {
   checkExportedNames();
 
   checkDefersAfterParsing();
+
+  forv_Vec(UseStmt, use, gUseStmts) {
+    checkUseStmt(use);
+  }
 }
 
 
@@ -607,3 +612,17 @@ static void warnUnstableLeadingUnderscores() {
     }
   }
 }
+
+/* check for 'public use M only' and warn in that event since
+   it does nothing. (public use does not bring in the module named
+   unless it renames the module e.g. 'public use M as M only' */
+static void checkUseStmt(UseStmt* use) {
+  if (!use->isPrivate && !use->isARename() && use->hasOnlyNothing()) {
+    const char* name = "M";
+    if (auto used = toUnresolvedSymExpr(use->src))
+      name = used->unresolved;
+    USR_WARN(use, "'public use %s only;' has no effect", name);
+    USR_PRINT("try 'public import %s;' or 'public use %s as %s only;'",
+              name, name, name);
+  }
+}