override def createHighlightUsagesHandler()

in scala/scala-impl/src/org/jetbrains/plugins/scala/highlighter/usages/ScalaHighlightUsagesHandlerFactory.scala [27:141]
111 lines of code
60 McCabe index (conditional complexity)

  override def createHighlightUsagesHandler(editor: Editor, file: PsiFile): HighlightUsagesHandlerBase[_ <: PsiElement] = {
    if (!file.is[ScalaFile]) return null
    val offset = TargetElementUtil.adjustOffset(file, editor.getDocument, editor.getCaretModel.getOffset)
    val element: PsiElement = file.findElementAt(offset) match {
      case _: PsiWhiteSpace => file.findElementAt(offset - 1)
      case elem => elem
    }
    if (element == null || element.getNode == null) return null

    element.getParent match {
      case end: ScEnd =>
        val endMarkerHandler =
          if (end.tag.isIdentifier && end.tag == element) {
            end.begin.map(_.tag).collect {
              case named: ScNamedElement =>
                ScHighlightEndMarkerUsagesHandler(named, editor, file)
              case ref: ScStableCodeReference =>
                ScHighlightEndMarkerUsagesHandler(ref, editor, file)
            }
          } else None
        return endMarkerHandler.orNull
      case _ =>
    }

    element.getNode.getElementType match {
      case `kRETURN` =>
        val fun = PsiTreeUtil.getParentOfType(element, classOf[ScFunctionDefinition])
        if (fun != null) return new ScalaHighlightExitPointsHandler(fun, editor, file, element)
      case `kDEF` =>
        val fun = PsiTreeUtil.getParentOfType(element, classOf[ScFunction])
        fun match {
          case d: ScFunctionDefinition => return new ScalaHighlightExitPointsHandler(d, editor, file, element)
          case _ =>
        }
      case `kVAL` =>
        PsiTreeUtil.getParentOfType(element, classOf[ScPatternDefinition]) match {
          case pattern@ScPatternDefinition.expr(expr) if pattern.isSimple =>
            return new ScalaHighlightExprResultHandler(expr, editor, file, element)
          case _ =>
        }
      case `kVAR` =>
        PsiTreeUtil.getParentOfType(element, classOf[ScVariableDefinition]) match {
          case pattern@ScVariableDefinition.expr(expr) if pattern.isSimple =>
            return new ScalaHighlightExprResultHandler(expr, editor, file, element)
          case _ =>
        }
      case `kCASE` =>
        val cc = PsiTreeUtil.getParentOfType(element, classOf[ScCaseClause])
        if (cc != null) {
          cc.expr match {
            case Some(expr) =>
              return new ScalaHighlightExprResultHandler(expr, editor, file, element)
            case _ =>
          }
        }
      case `kMATCH` =>
        val matchStmt = PsiTreeUtil.getParentOfType(element, classOf[ScMatch])
        if (matchStmt != null) {
          return new ScalaHighlightExprResultHandler(matchStmt, editor, file, element)
        }
      case `kTRY` =>
        val tryStmt = PsiTreeUtil.getParentOfType(element, classOf[ScTry])
        if (tryStmt != null) {
          return new ScalaHighlightExprResultHandler(tryStmt, editor, file, element)
        }
      case `kFOR` =>
        val forStmt = PsiTreeUtil.getParentOfType(element, classOf[ScFor])
        if (forStmt != null && forStmt.isYield) {
          forStmt.body match {
            case Some(body) =>
              return new ScalaHighlightExprResultHandler(body, editor, file, element)
            case _ =>
          }
        }
      case `kIF` =>
        val ifStmt = PsiTreeUtil.getParentOfType(element, classOf[ScIf])
        if (ifStmt != null && ifStmt.elseExpression.isDefined) {
          return new ScalaHighlightExprResultHandler(ifStmt, editor, file, element)
        }
      case `tFUNTYPE` | `tFUNTYPE_ASCII` =>
        val maybeResult = element.getParent match {
          case funcExpr: ScFunctionExpr => funcExpr.result
          case caseClause: ScCaseClause => caseClause.resultExpr
          case _ => None
        }
        maybeResult match {
          case Some(resultExpr) =>
            return new ScalaHighlightExprResultHandler(resultExpr, editor, file, element)
          case _ =>
        }
      case IsTemplateDefinition() | ScalaTokenTypes.kTYPE =>
        val typeDefinition = PsiTreeUtil.getParentOfType(element, classOf[ScTypeDefinitionLike])
        if (typeDefinition != null) {
          return new CompanionHighlightHandler(element, typeDefinition, editor, file)
        }
      case `tIDENTIFIER` =>
        element.getParent match {
          case ScConstructorInvocation.byReference(constr) => return new ScalaHighlightConstructorInvocationUsages(constr, file, editor)
          case ref@ScConstructorInvocation.byUniversalApply(_) => return new ScalaHighlightConstructorInvocationUsages(Option(ref), file, editor)
          case named: ScNamedElement => return implicitHighlighter(editor, file, named)
          case ref@ReferenceToCaseClassApplyOrUnapply(cc) => return new ScalaHighlightCaseClassHandler(ref, cc, file, editor)
          case ref: ScReference => return implicitHighlighter(editor, file, ref)
          case _ =>
        }

      //to highlight usages of implicit parameter from context bound
      case `tCOLON` =>
        element.getNextSiblingNotWhitespaceComment match {
          case cb: ScContextBound => return implicitHighlighter(editor, file, cb)
          case _ =>
        }
      case _ =>
    }
    null
  }