private def defnTemplate()

in rsc/src/main/scala/rsc/outline/Scheduler.scala [302:396]
88 lines of code
26 McCabe index (conditional complexity)

  private def defnTemplate(env: Env, tree: DefnTemplate): Env = {
    mods(env, tree.mods)
    assignSym(env, tree)
    val tparamEnv = tparams(env, tree)
    val selfEnv = self(tparamEnv, tree)
    val templateEnv = {
      tree match {
        case tree: DefnPackageObject =>
          val packageScope = symtab.scopes(tree.id.sym.owner).asInstanceOf[PackageScope]
          val templateScope = PackageObjectScope(tree, packageScope)
          val templateEnv = templateScope :: packageScope :: selfEnv
          symtab.scopes.put(tree.id.sym, templateScope)
          todo.add(packageScope :: tparamEnv, templateScope)
          templateEnv
        case tree =>
          val templateScope = TemplateScope(tree)
          val templateEnv = templateScope :: selfEnv
          symtab.scopes.put(tree.id.sym, templateScope)
          todo.add(tparamEnv, templateScope)
          templateEnv
      }
    }
    stats(TemplateLevel, templateEnv, tree.earlies)
    parents(tparamEnv, tree)
    tree match {
      case tree: DefnClass =>
        tree.lang match {
          case ScalaLanguage | UnknownLanguage =>
            tree.primaryCtor.foreach(synthesizer.paramss(templateEnv, _))
            synthesizer.paramAccessors(templateEnv, tree)
            tree.primaryCtor.foreach(apply(templateEnv, _))
            if (tree.mods.hasTrait && tree.stats.exists(_.isInstanceOf[Term])) {
              synthesizer.traitConstructor(templateEnv, tree)
            }
          case JavaLanguage =>
            val hasCtor = tree.stats.exists(_.isInstanceOf[DefnCtor])
            if (!hasCtor && tree.hasClass) synthesizer.defaultConstructor(templateEnv, tree)
        }
      case tree: DefnObject =>
        val companionClass = symtab.outlines.get(tree.id.sym.companionClass)
        companionClass match {
          case Some(caseClass: DefnClass) if caseClass.hasDefaultParams =>
            synthesizer.defaultGetters(templateEnv, caseClass)
          case _ =>
            ()
        }
      case _ =>
        ()
    }
    stats(TemplateLevel, templateEnv, tree.stats)
    tree match {
      case tree: DefnClass =>
        if (tree.hasCase) {
          synthesizer.caseClassMembers(templateEnv, tree)
          symtab.caseEnvs.put(tree.id.sym, templateEnv)
          // We have to add companion members after the fact if
          // the case class is defined after the companion object
          // We can't add them while processing the companion object because
          // it needs the Env from processing the case class
          symtab.caseEnvs.get(tree.id.sym.companionObject).foreach { caseObjectTemplateEnv =>
            synthesizer.caseClassCompanionMembers(caseObjectTemplateEnv, tree)
          }
        }
        if (tree.hasEnum) {
          synthesizer.enumMembers(templateEnv, tree)
        }
        tree.parents.foreach {
          case Init(TptId("AnyVal"), Nil) =>
            synthesizer.valueClassMembers(templateEnv, tree)
          case _ =>
            ()
        }
      case tree: DefnObject =>
        if (tree.hasCase) {
          synthesizer.caseObjectMembers(templateEnv, tree)
        }
        val companionClassSym = tree.id.sym.companionClass
        val companionClass = symtab.outlines.get(companionClassSym)
        companionClass match {
          case Some(caseClass: DefnClass) if caseClass.hasCase =>
            symtab.caseEnvs.put(tree.id.sym, templateEnv)
            // We want to add case companion members only if we have the case class env already
            // This is because we need it to make sure that the primaryCtor paramss are desugared
            // The desugared paramss are then used in the companion apply method.
            symtab.caseEnvs.get(companionClassSym).foreach { caseClassTemplateEnv =>
              synthesizer.caseClassCompanionMembers(templateEnv, caseClass)
            }
          case _ =>
            ()
        }
      case _ =>
        ()
    }
    env
  }