bool isValid() const { return *this != SourceLocation(); }

// Returns a zero length location at the start of the current one.

SourceLocation startZeroLengthLocation() const

quint32 i = offset;

quint32 endLine = startLine;

quint32 endColumn = startColumn;

QChar c = text.at(i);

switch (c.unicode()) {

case '\n':

++i;

Q_FALLTHROUGH();

case '\r':

}

++i;

}

}

// attributes

*/

quint32 QQmlSA::SourceLocation::begin() const

{

}

/*!

*/

quint32 QQmlSA::SourceLocation::end() const

{

}

/*!

class ElementRef

{

public:

: element(RegionRef{ path, region }), size(size)

{

}

ElementRef() = default;

std::variant<AST::Node *, RegionRef> element;

};

/*!

bool preVisit(Node *n) override

{

if (!kindsToSkip().contains(n->kind)) {

if (!starts.contains(start))

starts.insert(start, { n, end - start });

if (!ends.contains(end))

return true;

}

};

void AstRangesVisitor::addNodeRanges(AST::Node *rootNode)

if (comments) {

auto regs = itemLocations->info().regions;

for (auto it = regs.cbegin(), end = regs.cend(); it != end; ++it) {

if (!shouldSkipRegion(item, it.key())) {

if (!starts.contains(startI))

if (!ends.contains(endI))

ends.insert(endI, { currentP, it.key(), endI - startI });

}

class CommentLinker

{

public:

const SourceLocation &commentLocation)

: m_code{ code },

m_commentedElement{ commentedElement },

[[nodiscard]] Comment createComment() const

{

const auto [preSpacesIndex, postSpacesIndex, preNewlineCount] = m_spaces;

}

private:

struct SpaceTrace

{

qsizetype iPost;

};

/*! \internal

*/

[[nodiscard]] SpaceTrace findSpacesAroundComment() const

{

QStringView commentStartStr;

while (iPre > 0) {

QChar c = m_code.at(iPre - 1);

} else if (c == QLatin1Char('\n') || c == QLatin1Char('\r')) {

preNewline = 1;

// possibly add an empty line if it was there (but never more than one)

if (c == QLatin1Char('\n') && i > 0 && m_code.at(i - 1) == QLatin1Char('\r'))

--i;

while (i > 0 && m_code.at(--i).isSpace()) {

// expression (think a + //comment\n b ==> a // comment\n + b), in this

// case attaching as preComment of iStart (b in the example) should be

// preferred as it is safe

while (i != 0 && m_code.at(--i).isSpace())

;

if (i <= preEnd.key() || i < m_lastPostCommentPostEnd

private:

QStringView m_code;

ElementRef &m_commentedElement;

Comment::CommentType m_commentType = Comment::Pre;

const AstRangesVisitor &m_ranges;

const SourceLocation &m_commentLocation;

ranges.addItemRanges(m_rootItem.item(), m_fileLocations, Path());

ranges.addNodeRanges(rootNode);

QStringView code = engine->code();

for (const SourceLocation &commentLocation : engine->comments()) {

// collect whitespace before and after cLoc -> iPre..iPost contains whitespace,

// do not add newline before, but add the one after

class FirstNodeVisitor : public VisitAll

{

public:

AST::Node *firstNodeInRange = nullptr;

bool preVisit(AST::Node *n) override

{

if (!VisitAll::uiKinds().contains(n->kind)) {

if (!firstNodeInRange && minStart <= start && end <= maxEnd && start < end)

firstNodeInRange = n;

}

}

};

{

FirstNodeVisitor visitor(minStart, maxEnd);

AST::Node::accept(n, &visitor);

const QQmlLSCompletionPosition &positionInfo)

{

auto fileLocations = FileLocations::treeOf(parentForContext)->info().fullRegion;

}

bool QQmlLSCompletion::cursorAfterColon(const DomItem &currentItem,

if (region == location.regions.constEnd())

return false;

return true;

}

return false;

const QQmlJS::SourceLocation propertyKeyword = info.regions[PropertyKeywordRegion];

// do completions for the keywords

const QQmlJS::SourceLocation readonlyKeyword = info.regions[ReadonlyKeywordRegion];

const QQmlJS::SourceLocation defaultKeyword = info.regions[DefaultKeywordRegion];

const QQmlJS::SourceLocation requiredKeyword = info.regions[RequiredKeywordRegion];

bool completeDefault = true;

// if there is already a readonly keyword before the cursor: do not auto complete it again

completeReadonly = false;

// also, required keywords do not like readonly keywords

completeRequired = false;

}

// same for required

completeRequired = false;

// also, required keywords do not like readonly keywords

completeReadonly = false;

}

// same for default

completeDefault = false;

}

auto addCompletionKeyword = [&result](QUtf8StringView view, bool complete) {

const QQmlJS::SourceLocation propertyIdentifier = info.regions[IdentifierRegion];

if (propertyKeyword.end() <= positionInfo.offset()

suggestReachableTypes(currentItem,

LocalSymbolsType::ObjectType | LocalSymbolsType::ValueType,

CompletionItemKind::Class, result);

// sanity check: is it the definition of the current binding? check if they both have their

// ':' at the same location

if (propertyDefinitionColon.isValid() && propertyDefinitionColon == smallestColon

return smallestPropertyDefinition;

}

}

filteredItems.append(*smallest);

const QQmlJS::SourceLocation smallestLoc = smallest->fileLocation->info().fullRegion;

for (auto it = items.begin(); it != items.end(); it++) {

if (it == smallest)

continue;

const QQmlJS::SourceLocation itLoc = it->fileLocation->info().fullRegion;

if (itBegin == smallestEnd || smallestBegin == itEnd) {

filteredItems.append(*it);

}

enum ComparisonOption { Normal, ExcludePositionAfterLast };

auto containsTarget = [targetPos](QQmlJS::SourceLocation l, ComparisonOption c) {

};

if (containsTarget(t->info().fullRegion, Normal)) {

ItemLocation loc;

return Location{ fileName, sourceLocation, textRowAndColumnFrom(code, sourceLocation.end()) };

}

{

code);

}

{

Edit rename;

rename.location = Location::from(fileName, code, startLine, startCharacter, length);

QQmlJS::SourceLocation sourceLocation() const { return m_sourceLocation; }

TextPosition end() const { return m_end; }

static Location from(const QString &fileName, const QQmlJS::SourceLocation &sourceLocation,

const QString &code);

static std::optional<Location> tryFrom(const QString &fileName,

Location location;

QString replacement;

friend bool operator<(const Edit &a, const Edit &b)

{

{

if (! nodeStack.isEmpty()) {

AST::Node *parent = nodeStack.last();

if (node->firstSourceLocation().begin() < parentBegin)

qDebug() << "first source loc failed: node:" << node->kind << "at" << node->firstSourceLocation().startLine << "/" << node->firstSourceLocation().startColumn

++startLine;

}

QCOMPARE(expected, found);

first.startLine, first.startColumn);

SourceLocation cStart = combined.startZeroLengthLocation();

SourceLocation cEnd = combined.endZeroLengthLocation(m_codeStr);

auto *literal = QQmlJS::AST::cast<QQmlJS::AST::StringLiteral *>(expression);

QVERIFY(literal);

QCOMPARE(literal->value, u"hello string");

QCOMPARE(literal->lastSourceLocation().end(), quint32(code.size()));

// test for correct handling escape sequences inside strings

literal = QQmlJS::AST::cast<QQmlJS::AST::StringLiteral *>(binaryExpression->left);

QVERIFY(literal);

QCOMPARE(literal->value, u"hello\n\tstring");

QCOMPARE(literal->firstSourceLocation().startLine, 1u);

QCOMPARE(literal->lastSourceLocation().end(), quint32(leftCode.size()));

literal = QQmlJS::AST::cast<QQmlJS::AST::StringLiteral *>(binaryExpression->right);

QVERIFY(literal);

QCOMPARE(literal->value, u"\nbye");

QCOMPARE(literal->firstSourceLocation().begin(), offset);

QCOMPARE(literal->firstSourceLocation().startLine, 1u);

QCOMPARE(literal->lastSourceLocation().end(), quint32(code.size()));

literal = QQmlJS::AST::cast<QQmlJS::AST::StringLiteral *>(binaryExpression->left);

QVERIFY(literal);

QCOMPARE(literal->value, u"\nhello\nbye");

QCOMPARE(literal->firstSourceLocation().startLine, 1u);

QCOMPARE(literal->lastSourceLocation().end(), leftCode.size());

literal = QQmlJS::AST::cast<QQmlJS::AST::StringLiteral *>(binaryExpression->right);

QVERIFY(literal);

QCOMPARE(literal->value, u"\nbye");

QCOMPARE(literal->firstSourceLocation().begin(), offset);

QCOMPARE(literal->lastSourceLocation().startLine, 3u);

QCOMPARE(literal->lastSourceLocation().end(), code.size());

auto *templateLiteral = QQmlJS::AST::cast<QQmlJS::AST::TemplateLiteral *>(expression);

QVERIFY(templateLiteral);

auto *e = templateLiteral->expression;

QVERIFY(e);

}

QVERIFY(literal);

QCOMPARE(literal->value, expected_value);

QCOMPARE(literal->lastSourceLocation().end(), quint32(code.size()));

}