ReturnItemsDef

abstract def canEqual(that: Any): Boolean

abstract def containsAggregate: Boolean

abstract def declareVariables(previousScope: Scope): SemanticCheck

abstract def includeExisting: Boolean

Users must specify return items for the projection, either all variables (*), no variables (-), or explicit expressions.

abstract def items: Seq[ReturnItem]

abstract def position: InputPosition

abstract def productArity: Int

abstract def productElement(n: Int): Any

abstract def semanticCheck: SemanticCheck

abstract def withExisting(includeExisting: Boolean): ReturnItemsDef

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def asCanonicalStringVal: String

final def asInstanceOf[T0]: T0

def checkTypes(expression: Expression, signatures: Seq[TypeSignature]): SemanticCheck

def clone(): AnyRef

def declareVariable(v: LogicalVariable, typeGen: TypeGenerator, positions: Set[InputPosition] = Set.empty, overriding: Boolean = false): (SemanticState) ⇒ Either[SemanticError, SemanticState]

def declareVariable(v: LogicalVariable, possibleTypes: TypeSpec): (SemanticState) ⇒ Either[SemanticError, SemanticState]

def dup(children: Seq[AnyRef]): ReturnItemsDef.this.type

def ensureDefined(v: LogicalVariable): (SemanticState) ⇒ Either[SemanticError, SemanticState]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def error(msg: String, position: InputPosition)(state: SemanticState): SemanticCheckResult

def expectType(possibleTypes: ⇒ TypeSpec, expression: Expression, messageGen: (String, String) ⇒ String = DefaultTypeMismatchMessageGenerator): SemanticCheck

def expectType(possibleTypes: ⇒ TypeSpec)(ctx: SemanticContext, expr: Expression): SemanticCheck

def expectType[Exp <: Expression](possibleTypes: TypeSpec, expressions: Traversable[Exp]): SemanticCheck

def expectType(typeGen: TypeGenerator, expression: Expression, messageGen: (String, String) ⇒ String): SemanticCheck

def expectType(possibleTypes: TypeSpec, opt: Option[Expression]): SemanticCheck

def expectType(typeGen: TypeGenerator, expression: Expression): SemanticCheck

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

def implicitVariable(v: LogicalVariable, possibleType: CypherType): (SemanticState) ⇒ Either[SemanticError, SemanticState]

final def isInstanceOf[T0]: Boolean

def isStarOnly: Boolean

def leastUpperBoundsOfTypes(traversable: TraversableOnce[Expression]): TypeGenerator

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val popStateScope: SemanticCheck

def possibleTypes(expression: Expression): TypeGenerator

def productIterator: Iterator[Any]

def productPrefix: String

val pushStateScope: SemanticCheck

def requireCypher10Support(msg: String, position: InputPosition): SemanticCheck

def requireMultigraphSupport(msg: String, position: InputPosition): SemanticCheck

def semanticCheck[A <: SemanticCheckable](traversable: TraversableOnce[A]): SemanticCheck

def semanticCheckFold[A](traversable: Traversable[A])(f: (A) ⇒ SemanticCheck): SemanticCheck

def specifyType(possibleTypes: ⇒ TypeSpec, expression: Expression): (SemanticState) ⇒ Either[SemanticError, SemanticState]

def specifyType(typeGen: TypeGenerator, expression: Expression): (SemanticState) ⇒ Either[SemanticError, SemanticState]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def typeSwitch(expr: Expression)(choice: (TypeSpec) ⇒ SemanticCheck): SemanticCheck

def types(expression: Expression): TypeGenerator

def unionOfTypes(traversable: TraversableOnce[Expression]): TypeGenerator

def unless(condition: Boolean)(check: ⇒ SemanticCheck): SemanticCheck

def validNumber(double: DoubleLiteral): Boolean

def validNumber(long: IntegerLiteral): Boolean

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def when(condition: Boolean)(check: ⇒ SemanticCheck): SemanticCheck

def withScopedState(check: ⇒ SemanticCheck): SemanticCheck