private def ascribeInferredType()

in scalafix/rules/src/main/scala/rsc/rules/RscCompat.scala [266:355]
86 lines of code
25 McCabe index (conditional complexity)

  private def ascribeInferredType(ctx: RuleCtx, target: RewriteTarget): Patch = {
    try {
      val typeString = config.hardcoded
        .get(target.symbol)
        .orElse {
          val symbol = target match {
            case target: RewriteDefn if target.varDefnPat =>
              s"${target.symbol.init}()."
            case _ =>
              target.symbol
          }
          symbols
            .info(symbol)
            .flatMap { info =>
              target match {
                case target: RewriteWithBody =>
                  target.body match {
                    case Term.ApplyType(Term.Name("implicitly"), _) if info.isImplicit =>
                      None
                    case Term.ApplyType(
                        Term.Select(Term.Name("Bijection"), Term.Name("connect")),
                        _) if info.isImplicit =>
                      None
                    case _ =>
                      val returnTypeOpt = info.signature match {
                        case s.MethodSignature(_, _, _: s.ConstantType) =>
                          None
                        case s.MethodSignature(_, _, returnType) =>
                          Some(returnType)
                        case s.ValueSignature(tpe) =>
                          // FIXME: https://github.com/scalameta/scalameta/issues/1725
                          Some(tpe)
                        case other =>
                          val details = other.asMessage.toProtoString
                          sys.error(s"unsupported outline: $details")
                      }
                      returnTypeOpt.map { returnType =>
                        val printer =
                          new SemanticdbPrinter(target.env, addedImportsScope, symbols, config)
                        printer.pprint(returnType)
                        printer.toString
                      }
                  }

                case target: RewriteInit =>
                  info.signature match {
                    case s.ClassSignature(_, (parent: s.TypeRef) +: _, _, _) =>
                      val printer =
                        new SemanticdbPrinter(target.env, addedImportsScope, symbols, config)
                      printer.rep("[", parent.typeArguments, ", ", "]")(printer.pprint)
                      Some(printer.toString)
                  }
              }
            }
        }
        .getOrElse("")
      if (typeString.nonEmpty) {
        target match {
          case target: RewriteDefn =>
            val before = {
              val lparenOpt = if (target.parens) "(" else ""
              ctx.addLeft(target.before, lparenOpt)
            }
            val after = {
              val whitespaceOpt = {
                if (TokenOps.needsLeadingSpaceBeforeColon(target.after)) " "
                else ""
              }
              val ascription = s": $typeString"
              val rparenOpt = if (target.parens) ")" else ""
              ctx.addRight(target.after, whitespaceOpt + ascription + rparenOpt)
            }
            before + after

          case target: RewriteDefault =>
            ctx.addRight(target.after, s": $typeString")

          case target: RewriteInit =>
            ctx.addRight(target.parentCtor, typeString)
        }
      } else {
        Patch.empty
      }
    } catch {
      case ex: Throwable =>
        val sw = new java.io.StringWriter()
        ex.printStackTrace(new PrintWriter(sw))
        Patch.lint(Diagnostic("RscCompat", sw.toString, target.pos))
    }
  }