Remove non_forcing_is_a? (sorbet#9540)

* Remove non_forcing_is_a?

* Suggestions from review

* Update website/docs/non-forcing-constants.md

Co-authored-by: Jake Zimmerman <[email protected]>

---------

Co-authored-by: Jake Zimmerman <[email protected]>

Author: elliottt

core/errors/resolver.h

@@ -64,7 +64,7 @@ constexpr ErrorClass ExperimentalAttachedClass{5056, StrictLevel::False};
 // constexpr ErrorClass GeneratedDeprecated{5056, StrictLevel::False};
 constexpr ErrorClass StaticAbstractModuleMethod{5057, StrictLevel::False};
 constexpr ErrorClass AttachedClassAsParam{5058, StrictLevel::False};
-constexpr ErrorClass LazyResolve{5059, StrictLevel::False};
+// constexpr ErrorClass LazyResolve{5059, StrictLevel::False};
 constexpr ErrorClass GenericTypeParamBoundMismatch{5060, StrictLevel::False};
 constexpr ErrorClass PrivateConstantReferenced{5061, StrictLevel::True};
 constexpr ErrorClass InvalidRequiredAncestor{5062, StrictLevel::True};

core/tools/generate_names.cc

@@ -170,7 +170,6 @@ NameDef names[] = {
     {"declareSealed", "sealed!"},
     {"revealType", "reveal_type"},
     {"absurd"},
-    {"nonForcingIsA_p", "non_forcing_is_a?"},
     {"valid_p", "valid?"},
     {"recursivelyValid_p", "recursively_valid?"},
     {"subtypeOf_p", "subtype_of?"},

gems/sorbet-runtime/lib/sorbet-runtime.rb

@@ -115,6 +115,5 @@ module T::Private::Types; end
 require_relative 'types/props/generated_code_validation'
 
 require_relative 'types/struct'
-require_relative 'types/non_forcing_constants'
 
 require_relative 'types/compatibility_patches'

gems/sorbet-runtime/lib/types/non_forcing_constants.rb

@@ -14,15 +14,13 @@ def name
 
     # overrides Base
     def recursively_valid?(obj)
-      # Re-implements non_forcing_is_a?
       return false if Object.autoload?(:Set) # Set is meant to be autoloaded but not yet loaded, this value can't be a Set
       return false unless Object.const_defined?(:Set) # Set is not loaded yet
       obj.is_a?(Set) && super
     end
 
     # overrides Base
     def valid?(obj)
-      # Re-implements non_forcing_is_a?
       return false if Object.autoload?(:Set) # Set is meant to be autoloaded but not yet loaded, this value can't be a Set
       return false unless Object.const_defined?(:Set) # Set is not loaded yet
       obj.is_a?(Set)
@@ -41,7 +39,6 @@ def initialize
       end
 
       def valid?(obj)
-        # Re-implements non_forcing_is_a?
         return false if Object.autoload?(:Set) # Set is meant to be autoloaded but not yet loaded, this value can't be a Set
         return false unless Object.const_defined?(:Set) # Set is not loaded yet
         obj.is_a?(Set)

gems/sorbet-runtime/lib/types/types/typed_set.rb

@@ -624,7 +624,6 @@ void Environment::updateKnowledge(core::Context ctx, cfg::LocalRef local, core::
         return;
     }
 
-    // TODO(jez) We should probably update this to be aware of T::NonForcingConstants.non_forcing_is_a?
     if (send->fun == core::Names::kindOf_p() || send->fun == core::Names::isA_p() ||
         send->fun == core::Names::instanceOf_p()) {
         const auto &klassType = send->args[0].type;

gems/sorbet-runtime/test/types/non_forcing_constants.rb

@@ -485,9 +485,3 @@ module T::Utils::Nilable
   }
   def self.get_underlying_type_object(prop_type); end
 end
-
-module T::NonForcingConstants
-  # See <https://sorbet.org/docs/non-forcing-constants> for full docs.
-  sig {params(val: BasicObject, klass: String).returns(T::Boolean)}
-  def self.non_forcing_is_a?(val, klass); end
-end

infer/environment.cc

@@ -2536,107 +2536,6 @@ class ResolveTypeMembersAndFieldsWalk {
         }
     }
 
-    void validateNonForcingIsA(core::Context ctx, const ast::Send &send) {
-        constexpr string_view method = "T::NonForcingConstants.non_forcing_is_a?";
-
-        if (send.numPosArgs() != 2) {
-            return;
-        }
-
-        auto numKwArgs = send.numKwArgs();
-        if (numKwArgs > 1) {
-            return;
-        }
-
-        auto stringLoc = send.getPosArg(1).loc();
-
-        auto literalNode = ast::cast_tree<ast::Literal>(send.getPosArg(1));
-        if (literalNode == nullptr) {
-            if (auto e = ctx.beginError(stringLoc, core::errors::Resolver::LazyResolve)) {
-                e.setHeader("`{}` only accepts string literals", method);
-            }
-            return;
-        }
-
-        if (!core::isa_type<core::NamedLiteralType>(literalNode->value)) {
-            if (auto e = ctx.beginError(stringLoc, core::errors::Resolver::LazyResolve)) {
-                e.setHeader("`{}` only accepts string literals", method);
-            }
-            return;
-        }
-
-        auto literal = core::cast_type_nonnull<core::NamedLiteralType>(literalNode->value);
-        if (literal.kind != core::NamedLiteralType::Kind::String) {
-            // Infer will report a type error
-            return;
-        }
-
-        auto shortName = literal.name.shortName(ctx);
-        if (shortName.empty()) {
-            if (auto e = ctx.beginError(stringLoc, core::errors::Resolver::LazyResolve)) {
-                e.setHeader("The string given to `{}` must not be empty", method);
-            }
-            return;
-        }
-
-        // If this string _begins_ with `::`, then the first fragment will be an empty string; in multiple places
-        // below, we'll check to find out whether the first part is `""` or not, which means we're testing whether
-        // the string did or did not begin with `::`.
-        vector<string_view> parts = absl::StrSplit(shortName, "::");
-
-        core::SymbolRef current;
-        for (auto part : parts) {
-            if (!current.exists()) {
-                current = core::Symbols::root();
-
-                // First iteration
-                if (part != "") {
-                    if (auto e = ctx.beginError(stringLoc, core::errors::Resolver::LazyResolve)) {
-                        e.setHeader("The string given to `{}` must be an absolute constant reference that "
-                                    "starts with `{}`",
-                                    method, "::");
-                    }
-                    return;
-                }
-                continue;
-            }
-
-            auto member = ctx.state.lookupNameConstant(part);
-            if (!member.exists()) {
-                if (auto e = ctx.beginError(stringLoc, core::errors::Resolver::LazyResolve)) {
-                    auto prettyCurrent = current == core::Symbols::root() ? "" : "::" + current.show(ctx);
-                    auto pretty = fmt::format("{}::{}", prettyCurrent, part);
-                    e.setHeader("Unable to resolve constant `{}`", pretty);
-                }
-                return;
-            }
-
-            core::SymbolRef newCurrent;
-            if (current.isClassOrModule()) {
-                newCurrent = current.asClassOrModuleRef().data(ctx)->findMember(ctx, member);
-            }
-            if (!newCurrent.exists()) {
-                if (auto e = ctx.beginError(stringLoc, core::errors::Resolver::LazyResolve)) {
-                    auto prettyCurrent = current == core::Symbols::root() ? "" : "::" + current.show(ctx);
-                    auto pretty = fmt::format("{}::{}", prettyCurrent, part);
-                    e.setHeader("Unable to resolve constant `{}`", pretty);
-                }
-                return;
-            }
-            current = newCurrent;
-        }
-
-        ENFORCE(current.exists(), "Loop invariant violated");
-
-        if (!current.isClassOrModule()) {
-            if (auto e = ctx.beginError(stringLoc, core::errors::Resolver::LazyResolve)) {
-                e.setHeader("The string given to `{}` must resolve to a class or module", method);
-                e.addErrorLine(current.loc(ctx), "Resolved to this constant");
-            }
-            return;
-        }
-    }
-
     core::ClassOrModuleRef methodOwner(core::Context ctx) {
         core::ClassOrModuleRef owner = ctx.owner.enclosingClass(ctx);
         if (owner == core::Symbols::root()) {
@@ -2868,9 +2767,6 @@ class ResolveTypeMembersAndFieldsWalk {
                     }
                     return;
                 }
-                case core::Names::nonForcingIsA_p().rawId():
-                    validateNonForcingIsA(ctx, send);
-                    return;
                 default:
                     return;
             }