code: Type instantiatePolymorphicSignatureInstance(Env<AttrContext> env,
                                              MethodSymbol spMethod,  // sig. poly. method or null if none
                                              Resolve.MethodResolutionContext resolveContext,
                                              List<Type> argtypes) {
          final Type restype;
  
          //The return type for a polymorphic signature call is computed from
          //the enclosing tree E, as follows: if E is a cast, then use the
          //target type of the cast expression as a return type; if E is an
          //expression statement, the return type is 'void' - otherwise the
          //return type is simply 'Object'. A correctness check ensures that
          //env.next refers to the lexically enclosing environment in which
          //the polymorphic signature call environment is nested.
  
          switch (env.next.tree.getTag()) {
              case TYPECAST:
                  JCTypeCast castTree = (JCTypeCast)env.next.tree;
                  restype = (TreeInfo.skipParens(castTree.expr) == env.tree) ?
                      castTree.clazz.type :
                      syms.objectType;
                  break;
              case EXEC:
                  JCTree.JCExpressionStatement execTree =
                          (JCTree.JCExpressionStatement)env.next.tree;
                  restype = (TreeInfo.skipParens(execTree.expr) == env.tree) ?
                      syms.voidType :
                      syms.objectType;
                  break;
              default:
                  restype = syms.objectType;
          }
  
          List<Type> paramtypes = Type.map(argtypes, new ImplicitArgType(spMethod, resolveContext.step));
          List<Type> exType = spMethod != null ?
              spMethod.getThrownTypes() :
              List.of(syms.throwableType); // make it throw all exceptions
  
          MethodType mtype = new MethodType(paramtypes,
                                            restype,
                                            exType,
                                            syms.methodClass);
          return mtype;
      }
docs: Compute a synthetic method type corresponding to the requested polymorphic
  method signature. The target return type is computed from the immediately
  enclosing scope surrounding the polymorphic-signature call.