return o.Cluster
}

// Position is a representation of the location of a source.
type Position struct {
	Filename string // filename, if any
	Line     int    // line number, starting at 1
}

// String outputs the string representation of the position.
func (p *Position) String() string {
	s := p.Filename
	// TODO: support json file position.
	if p.isValid() && filepath.Ext(p.Filename) != ".json" {

    if (obj instanceof Parameter) {
      Parameter that = (Parameter) obj;
      return position == that.position && declaration.equals(that.declaration);
    }
    return false;
  }

  @Override
  public int hashCode() {
    return position;
  }

  @Override
  public String toString() {
    return type + " arg" + position;
  }

    if (obj instanceof Parameter) {
      Parameter that = (Parameter) obj;
      return position == that.position && declaration.equals(that.declaration);
    }
    return false;
  }

  @Override
  public int hashCode() {
    return position;
  }

  @Override
  public String toString() {
    return type + " arg" + position;
  }

        if (position == 0) {
            setPosition(1);
        }
        return (attribute == null) ? null : new Xpp3DomAttributePointer(parent, attribute);
    }

    public int getPosition() {
        return position;
    }

    public boolean setPosition(int position) {
        this.position = position;

    public object TO_DENOTABLE : KaRendererTypeApproximator {
        override fun approximateType(analysisSession: KaSession, type: KaType, position: Variance): KaType {
            with(analysisSession) {
                val effectiveType = type.getEnhancedType() ?: type

                return when (position) {
                    Variance.INVARIANT -> effectiveType

type atPos token.Pos

func (s atPos) Pos() token.Pos {
	return token.Pos(s)
}

// posSpan holds a position range along with a highlighted position within that
// range. This is used for positioning errors, with pos by convention being the
// first position in the source where the error is known to exist, and start
// and end defining the full span of syntax being considered when the error was

	}
	return true
}

// TODO(gri) Consider a more direct (position-independent) mechanism
//           to identify which file we're in so that version checks
//           work correctly in the absence of correct position info.

// fileFor returns the *ast.File which contains the position pos.
// If there are no files, the result is nil.
// The position must be valid.
func (check *Checker) fileFor(pos token.Pos) *ast.File {

// The position Pos, if valid, points to the beginning of
// the offending token, and the error condition is described
// by Msg.
type Error struct {
	Pos token.Position
	Msg string
}

// Error implements the error interface.
func (e Error) Error() string {
	if e.Pos.Filename != "" || e.Pos.IsValid() {
		// don't print "<unknown position>"

/**
 * A virtual console screen cursor. This class avoid complex screen position management.
 */
public class Cursor {
    int col; // count from left of screen, 0 = left most
    int row; // count from bottom of screen, 0 = bottom most, 1 == 2nd from bottom

    @SuppressWarnings("ReferenceEquality")
    public void copyFrom(Cursor position) {
        if (position == this) {
            return;
        }
        this.col = position.col;

		// dollar patterns must have the {$} in the same position.
		return apply(idx.segments[routingIndexKey{s: "/", pos: len(pat.segments) - 1}])
	}
	// For ordinary and multi patterns, the only conflicts can be with a multi,
	// or a pattern that has the same literal or a wildcard at some literal
	// position.
	// We could intersect all the possible matches at each position, but we