TransparentPosition

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

Test two objects for inequality.

final def ##(): Int

Equivalent to x.hashCode except for boxed numeric types and null.

def +(other: String): String

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

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

Test two objects for equality.

def add(attachment: Any): Attachments { type Pos = TransparentPosition.this.Pos }

Creates a copy of this attachment with its payload updated

def all: Predef.Set[Any]

Gets the underlying payload

final def asInstanceOf[T0]: T0

Cast the receiver object to be of type T0.

def clone(): AnyRef

Create a copy of the receiver object.

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

Tests whether the argument (arg0) is a reference to the receiver object (this).

def equals(that: Any): Boolean

The equality method for reference types.

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

Called by the garbage collector on the receiver object when there are no more references to the object.

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

Returns string formatted according to given format string.

def get[T](implicit arg0: ClassTag[T]): Option[T]

final def getClass(): Class[_]

A representation that corresponds to the dynamic class of the receiver object.

def hashCode(): Int

The hashCode method for reference types.

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

Test whether the dynamic type of the receiver object is T0.

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

Equivalent to !(this eq that).

final def notify(): Unit

Wakes up a single thread that is waiting on the receiver object's monitor.

final def notifyAll(): Unit

Wakes up all threads that are waiting on the receiver object's monitor.

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 pointOrElse(default: Int): Int

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

def pos: Position

Gets the underlying position

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 remove[T](implicit arg0: ClassTag[T]): Attachments { type Pos = TransparentPosition.this.Pos }

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

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

Creates a String representation of this object.

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 withPoint(off: Int): RangePosition

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

def withPos(newPos: Position): Attachments { type Pos = TransparentPosition.this.Pos }

Creates a copy of this attachment with its position updated

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)

val self: Any

val self: Any

def offset: Option[Int]

def x: TransparentPosition

def x: TransparentPosition