TransparentPosition

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (TransparentPosition, B)

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def column: Int

def dbgString: String

def endOrPoint: Int

The end of the position's range, or point if not a range position

def ensuring(cond: (TransparentPosition) ⇒ Boolean, msg: ⇒ Any): TransparentPosition

def ensuring(cond: (TransparentPosition) ⇒ Boolean): TransparentPosition

def ensuring(cond: Boolean, msg: ⇒ Any): TransparentPosition

def ensuring(cond: Boolean): TransparentPosition

final def eq(arg0: AnyRef): Boolean

def equals(that: Any): Boolean

def fileContent: Array[Char]

Contents of the source file that contains this position.

def fileInfo: File

Java file corresponding to the source file of this position.

def finalize(): Unit

def focus: Position

If this is a range position, the offset position of its point.

def focusEnd: OffsetPosition

If this is a range position, the offset position of its end.

def focusStart: OffsetPosition

If this is a range position, the offset position of its start.

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hashCode(): Int

def inUltimateSource(source: SourceFile): Position

Map this position to a position in an original source file.

def includes(pos: Position): Boolean

Does this position include the given position pos.

def isDefined: Boolean

Is this position neither a NoPosition nor a FakePosition? If isDefined is true, offset and source are both defined.

final def isInstanceOf[T0]: Boolean

def isOpaqueRange: Boolean

Is this position a non-transparent range position?

def isRange: Boolean

Is this position a range position?

def isTransparent: Boolean

Is this position a transparent position?

def line: Int

def lineContent: String

def makeTransparent: TransparentPosition

if opaque range, make this position transparent

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def overlaps(pos: Position): Boolean

Does this position overlap with that position? This holds if both positions are ranges and there is an interval of non-zero length that is shared by both position ranges.

def payload: Position

Exposes itself as payload of Attachment

def pointOrElse(default: Int): Int

The point (where the ^ is) of the position, or else default if undefined

def pos: Position

Exposes itself as payload of Attachment

def precedes(pos: Position): Boolean

Does this position precede that position? This holds if both positions are defined and the end point of this position is not larger than the start point of the given position.

def properlyIncludes(pos: Position): Boolean

Does this position properly include the given position pos ("properly" meaning their ranges are not the same)?

def properlyPrecedes(pos: Position): Boolean

Does this position properly precede the given position pos ("properly" meaning their ranges do not share a common point).

def safeLine: Int

def sameRange(pos: Position): Boolean

Does this position cover the same range as that position? Holds only if both position are ranges

val self: Any

val self: Any

def show: String

def startOrPoint: Int

The start of the position's range, or point if not a range position

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

def toSingleLine: Position

Convert this to a position around point that spans a single source line

def toString(): String

def union(pos: Position): Position

If this is a range, the union with the other range, with the point of this position.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withEnd(off: Int): RangePosition

The same position with a different end value (if a range)

def withPayload(newPos: Any): Attachment

A bit weird method that is necessary to safely update positions without destroying custom attachments

def withPoint(off: Int): RangePosition

The same position with a different point value (if a range or offset)

def withPos(newPos: Position): Attachment

A bit weird method that is necessary to safely update positions without destroying custom attachments

def withSource(source: SourceFile, shift: Int): RangePosition

The same position with a different source value, and its values shifted by given offset

def withStart(off: Int): RangePosition

The same position with a different start value (if a range)

def →[B](y: B): (TransparentPosition, B)

def offset: Option[Int]

def x: TransparentPosition

def x: TransparentPosition