def isDefinedAt()

in repository/src/main/scala/org/apache/atlas/query/Resolver.scala [31:116]
80 lines of code
33 McCabe index (conditional complexity)

    def isDefinedAt(x: Expression) = true

    def apply(e: Expression): Expression = e match {
        case idE@IdExpression(name, exprType) => {

            val backExpr = aliases.get(name)
            if (backExpr.isDefined) {
                  if(backExpr.get.resolved) {
                     return new BackReference(name, backExpr.get, None)
                  }
                  else {
                    //replace once resolved
                    return idE;
                  }
            }

            if (srcExpr.isDefined) {
                val fInfo = resolveReference(srcExpr.get.dataType, name)
                if (fInfo.isDefined) {
                    return new FieldExpression(name, fInfo.get, None)
                }
            }

            if(exprType.isTypeAllowed) {
                val dt = resolveAsDataType(name);
                if(dt.isDefined) {
                    if(dt.get.isInstanceOf[ClassType]) {
                         return new ClassExpression(name)
                    }
                    if(dt.get.isInstanceOf[TraitType]) {
                      return new TraitExpression(name)
                    }
                }
             }
            idE
        }
        case ce@ClassExpression(clsName) if connectClassExprToSrc && srcExpr.isDefined => {
            val fInfo = resolveReference(srcExpr.get.dataType, clsName)
            if (fInfo.isDefined) {
                return new FieldExpression(clsName, fInfo.get, None)
            }
            ce
        }
        case f@UnresolvedFieldExpression(child, fieldName) if child.resolved => {
            var fInfo: Option[FieldInfo] = None

            fInfo = resolveReference(child.dataType, fieldName)
            if (fInfo.isDefined) {
                return new FieldExpression(fieldName, fInfo.get, Some(child))
            }
            val tType = resolveAsTraitType(fieldName)
            if (tType.isDefined) {
              return new FieldExpression(fieldName, FieldInfo(child.dataType, null, null, fieldName), Some(child))
            }
            f
        }
        case isTraitLeafExpression(traitName, classExpression)
            if srcExpr.isDefined && !classExpression.isDefined =>
            isTraitLeafExpression(traitName, srcExpr)
        case hasFieldLeafExpression(traitName, classExpression)
            if srcExpr.isDefined && !classExpression.isDefined =>
            hasFieldLeafExpression(traitName, srcExpr)
        case f@FilterExpression(inputExpr, condExpr) if inputExpr.resolved => {
            val r = new Resolver(Some(inputExpr), inputExpr.namedExpressions)
            return new FilterExpression(inputExpr, condExpr.transformUp(r))
        }
        case SelectExpression(child, selectList, forGroupBy) if child.resolved => {
            val r = new Resolver(Some(child), child.namedExpressions)
            return new SelectExpression(child, selectList.map {
                _.transformUp(r)
            }, forGroupBy)
        }
        case l@LoopExpression(inputExpr, loopExpr, t) if inputExpr.resolved => {
            val r = new Resolver(Some(inputExpr), inputExpr.namedExpressions, true)
            return new LoopExpression(inputExpr, loopExpr.transformUp(r), t)
            }
        case lmt@LimitExpression(child, limit, offset) => {
            val r = new Resolver(Some(child), child.namedExpressions)
            return new LimitExpression(child.transformUp(r), limit, offset)
        }
        case order@OrderExpression(child, odr, asc) => {
            val r = new Resolver(Some(child), child.namedExpressions)
            return new OrderExpression(child, odr.transformUp(r), asc)
        }
        case x => x
    }