1// Copyright (C) 2016 The Qt Company Ltd.
2// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
3
4#include "qqmlirbuilder_p.h"
5
6#include <private/qv4staticvalue_p.h>
7#include <private/qv4compileddata_p.h>
8#include <private/qqmljsparser_p.h>
9#include <private/qqmljslexer_p.h>
10#include <private/qv4compilerscanfunctions_p.h>
11#include <QCoreApplication>
12#include <QCryptographicHash>
13#include <cmath>
14
15QT_USE_NAMESPACE
16
17using namespace Qt::StringLiterals;
18
19static const quint32 emptyStringIndex = 0;
20using namespace QmlIR;
21using namespace QQmlJS;
22
23#define COMPILE_EXCEPTION(location, desc) \
24 { \
25 recordError(location, desc); \
26 return false; \
27 }
28
29void Object::simplifyRequiredProperties() {
30 // if a property of the current object was marked as required
31 // do not store that information in the ExtraData
32 // but rather mark the property as required
33 QSet<int> required;
34 for (auto it = this->requiredPropertyExtraDataBegin(); it != this->requiredPropertyExtraDataEnd(); ++it)
35 required.insert(value: it->nameIndex);
36 if (required.isEmpty())
37 return;
38 for (auto it = this->propertiesBegin(); it != this->propertiesEnd(); ++it) {
39 auto requiredIt = required.find(value: it->nameIndex);
40 if (requiredIt != required.end()) {
41 it->setIsRequired(true);
42 required.erase(i: requiredIt);
43 }
44 }
45 QmlIR::RequiredPropertyExtraData *prev = nullptr;
46 auto current = this->requiredPropertyExtraDatas->first;
47 while (current) {
48 if (required.contains(value: current->nameIndex))
49 prev = current;
50 else
51 requiredPropertyExtraDatas->unlink(before: prev, item: current);
52 current = current->next;
53 }
54}
55
56bool Parameter::initType(
57 QV4::CompiledData::ParameterType *paramType,
58 const QString &typeName, int typeNameIndex,
59 QV4::CompiledData::ParameterType::Flag listFlag)
60{
61 auto builtinType = stringToBuiltinType(typeName);
62 if (builtinType == QV4::CompiledData::CommonType::Invalid) {
63 if (typeName.isEmpty()) {
64 paramType->set(flags: listFlag, typeNameIndexOrCommonType: 0);
65 return false;
66 }
67 Q_ASSERT(quint32(typeNameIndex) < (1u << 31));
68 paramType->set(flags: listFlag, typeNameIndexOrCommonType: typeNameIndex);
69 } else {
70 Q_ASSERT(quint32(builtinType) < (1u << 31));
71 paramType->set(flags: listFlag | QV4::CompiledData::ParameterType::Common,
72 typeNameIndexOrCommonType: static_cast<quint32>(builtinType));
73 }
74 return true;
75}
76
77QV4::CompiledData::CommonType Parameter::stringToBuiltinType(const QString &typeName)
78{
79 static const struct TypeNameToType {
80 const char *name;
81 size_t nameLength;
82 QV4::CompiledData::CommonType type;
83 } propTypeNameToTypes[] = {
84 { .name: "void", .nameLength: strlen(s: "void"), .type: QV4::CompiledData::CommonType::Void },
85 { .name: "int", .nameLength: strlen(s: "int"), .type: QV4::CompiledData::CommonType::Int },
86 { .name: "bool", .nameLength: strlen(s: "bool"), .type: QV4::CompiledData::CommonType::Bool },
87 { .name: "double", .nameLength: strlen(s: "double"), .type: QV4::CompiledData::CommonType::Real },
88 { .name: "real", .nameLength: strlen(s: "real"), .type: QV4::CompiledData::CommonType::Real },
89 { .name: "string", .nameLength: strlen(s: "string"), .type: QV4::CompiledData::CommonType::String },
90 { .name: "url", .nameLength: strlen(s: "url"), .type: QV4::CompiledData::CommonType::Url },
91 { .name: "date", .nameLength: strlen(s: "date"), .type: QV4::CompiledData::CommonType::DateTime },
92 { .name: "regexp", .nameLength: strlen(s: "regexp"), .type: QV4::CompiledData::CommonType::RegExp },
93 { .name: "rect", .nameLength: strlen(s: "rect"), .type: QV4::CompiledData::CommonType::Rect },
94 { .name: "point", .nameLength: strlen(s: "point"), .type: QV4::CompiledData::CommonType::Point },
95 { .name: "size", .nameLength: strlen(s: "size"), .type: QV4::CompiledData::CommonType::Size },
96 { .name: "variant", .nameLength: strlen(s: "variant"), .type: QV4::CompiledData::CommonType::Var },
97 { .name: "var", .nameLength: strlen(s: "var"), .type: QV4::CompiledData::CommonType::Var }
98 };
99 static const int propTypeNameToTypesCount = sizeof(propTypeNameToTypes) /
100 sizeof(propTypeNameToTypes[0]);
101
102 for (int typeIndex = 0; typeIndex < propTypeNameToTypesCount; ++typeIndex) {
103 const TypeNameToType *t = propTypeNameToTypes + typeIndex;
104 if (typeName == QLatin1String(t->name, static_cast<int>(t->nameLength))) {
105 return t->type;
106 }
107 }
108 return QV4::CompiledData::CommonType::Invalid;
109}
110
111void Object::init(QQmlJS::MemoryPool *pool, int typeNameIndex, int idIndex,
112 const QV4::CompiledData::Location &loc)
113{
114 Q_ASSERT(loc.line() > 0 && loc.column() > 0);
115 inheritedTypeNameIndex = typeNameIndex;
116 location = loc;
117 idNameIndex = idIndex;
118 id = -1;
119 indexOfDefaultPropertyOrAlias = -1;
120 defaultPropertyIsAlias = false;
121 flags = QV4::CompiledData::Object::NoFlag;
122 properties = pool->New<PoolList<Property> >();
123 aliases = pool->New<PoolList<Alias> >();
124 qmlEnums = pool->New<PoolList<Enum>>();
125 qmlSignals = pool->New<PoolList<Signal> >();
126 bindings = pool->New<PoolList<Binding> >();
127 functions = pool->New<PoolList<Function> >();
128 functionsAndExpressions = pool->New<PoolList<CompiledFunctionOrExpression> >();
129 inlineComponents = pool->New<PoolList<InlineComponent>>();
130 requiredPropertyExtraDatas = pool->New<PoolList<RequiredPropertyExtraData>>();
131 declarationsOverride = nullptr;
132}
133
134QString IRBuilder::sanityCheckFunctionNames(Object *obj, const QSet<QString> &illegalNames, QQmlJS::SourceLocation *errorLocation)
135{
136 QSet<int> functionNames;
137 for (auto functionit = obj->functionsBegin(); functionit != obj->functionsEnd(); ++functionit) {
138 Function *f = functionit.ptr;
139 errorLocation->startLine = f->location.line();
140 errorLocation->startColumn = f->location.column();
141 if (functionNames.contains(value: f->nameIndex))
142 return tr(sourceText: "Duplicate method name");
143 functionNames.insert(value: f->nameIndex);
144
145 for (auto signalit = obj->signalsBegin(); signalit != obj->signalsEnd(); ++signalit) {
146 QmlIR::Signal *s = signalit.ptr;
147 if (s->nameIndex == f->nameIndex)
148 return tr(sourceText: "Duplicate method name");
149 }
150
151 const QString name = stringAt(index: f->nameIndex);
152 if (name.at(i: 0).isUpper())
153 return tr(sourceText: "Method names cannot begin with an upper case letter");
154 if (illegalNames.contains(value: name))
155 return tr(sourceText: "Illegal method name");
156 }
157 return QString(); // no error
158}
159
160QString Object::appendEnum(Enum *enumeration)
161{
162 Object *target = declarationsOverride;
163 if (!target)
164 target = this;
165
166 for (Enum *e = qmlEnums->first; e; e = e->next) {
167 if (e->nameIndex == enumeration->nameIndex)
168 return tr(sourceText: "Duplicate scoped enum name");
169 }
170
171 target->qmlEnums->append(item: enumeration);
172 return QString(); // no error
173}
174
175QString Object::appendSignal(Signal *signal)
176{
177 Object *target = declarationsOverride;
178 if (!target)
179 target = this;
180
181 for (Signal *s = qmlSignals->first; s; s = s->next) {
182 if (s->nameIndex == signal->nameIndex)
183 return tr(sourceText: "Duplicate signal name");
184 }
185
186 target->qmlSignals->append(item: signal);
187 return QString(); // no error
188}
189
190QString Object::appendProperty(Property *prop, const QString &propertyName, bool isDefaultProperty, const QQmlJS::SourceLocation &defaultToken, QQmlJS::SourceLocation *errorLocation)
191{
192 Object *target = declarationsOverride;
193 if (!target)
194 target = this;
195
196 for (Property *p = target->properties->first; p; p = p->next)
197 if (p->nameIndex == prop->nameIndex)
198 return tr(sourceText: "Duplicate property name");
199
200 for (Alias *a = target->aliases->first; a; a = a->next)
201 if (a->nameIndex() == prop->nameIndex)
202 return tr(sourceText: "Property duplicates alias name");
203
204 if (propertyName.constData()->isUpper())
205 return tr(sourceText: "Property names cannot begin with an upper case letter");
206
207 const int index = target->properties->append(item: prop);
208 if (isDefaultProperty) {
209 if (target->indexOfDefaultPropertyOrAlias != -1) {
210 *errorLocation = defaultToken;
211 return tr(sourceText: "Duplicate default property");
212 }
213 target->indexOfDefaultPropertyOrAlias = index;
214 }
215 return QString(); // no error
216}
217
218QString Object::appendAlias(Alias *alias, const QString &aliasName, bool isDefaultProperty, const QQmlJS::SourceLocation &defaultToken, QQmlJS::SourceLocation *errorLocation)
219{
220 Object *target = declarationsOverride;
221 if (!target)
222 target = this;
223
224 const auto aliasWithSameName = std::find_if(first: target->aliases->begin(), last: target->aliases->end(), pred: [&alias](const Alias &targetAlias){
225 return targetAlias.nameIndex() == alias->nameIndex();
226 });
227 if (aliasWithSameName != target->aliases->end())
228 return tr(sourceText: "Duplicate alias name");
229
230 const auto aliasSameAsProperty = std::find_if(first: target->properties->begin(), last: target->properties->end(), pred: [&alias](const Property &targetProp){
231 return targetProp.nameIndex == alias->nameIndex();
232 });
233
234 if (aliasSameAsProperty != target->properties->end())
235 return tr(sourceText: "Alias has same name as existing property");
236
237 if (aliasName.constData()->isUpper())
238 return tr(sourceText: "Alias names cannot begin with an upper case letter");
239
240 const int index = target->aliases->append(item: alias);
241
242 if (isDefaultProperty) {
243 if (target->indexOfDefaultPropertyOrAlias != -1) {
244 *errorLocation = defaultToken;
245 return tr(sourceText: "Duplicate default property");
246 }
247 target->indexOfDefaultPropertyOrAlias = index;
248 target->defaultPropertyIsAlias = true;
249 }
250
251 return QString(); // no error
252}
253
254void Object::appendFunction(QmlIR::Function *f)
255{
256 // Unlike properties, a function definition inside a grouped property does not go into
257 // the surrounding object. It's been broken since the Qt 5 era, and the semantics
258 // seems super confusing, so it wouldn't make sense to support that.
259 Q_ASSERT(!declarationsOverride);
260 functions->append(item: f);
261}
262
263void Object::appendInlineComponent(InlineComponent *ic)
264{
265 inlineComponents->append(item: ic);
266}
267
268void Object::appendRequiredPropertyExtraData(RequiredPropertyExtraData *extraData)
269{
270 requiredPropertyExtraDatas->append(item: extraData);
271}
272
273QString Object::appendBinding(Binding *b, bool isListBinding)
274{
275 const bool bindingToDefaultProperty = (b->propertyNameIndex == quint32(0));
276 if (!isListBinding
277 && !bindingToDefaultProperty
278 && b->type() != QV4::CompiledData::Binding::Type_GroupProperty
279 && b->type() != QV4::CompiledData::Binding::Type_AttachedProperty
280 && !b->hasFlag(flag: QV4::CompiledData::Binding::IsOnAssignment)) {
281 Binding *existing = findBinding(nameIndex: b->propertyNameIndex);
282 if (existing
283 && existing->isValueBinding() == b->isValueBinding()
284 && !existing->hasFlag(flag: QV4::CompiledData::Binding::IsOnAssignment)) {
285 return tr(sourceText: "Property value set multiple times");
286 }
287 }
288 if (bindingToDefaultProperty)
289 insertSorted(b);
290 else
291 bindings->prepend(item: b);
292 return QString(); // no error
293}
294
295Binding *Object::findBinding(quint32 nameIndex) const
296{
297 for (Binding *b = bindings->first; b; b = b->next)
298 if (b->propertyNameIndex == nameIndex)
299 return b;
300 return nullptr;
301}
302
303void Object::insertSorted(Binding *b)
304{
305 Binding *insertionPoint = bindings->findSortedInsertionPoint<quint32, Binding, &Binding::offset>(item: b);
306 bindings->insertAfter(insertionPoint, item: b);
307}
308
309QString Object::bindingAsString(Document *doc, int scriptIndex) const
310{
311 CompiledFunctionOrExpression *foe = functionsAndExpressions->slowAt(index: scriptIndex);
312 QQmlJS::AST::Node *node = foe->node;
313 if (QQmlJS::AST::ExpressionStatement *exprStmt = QQmlJS::AST::cast<QQmlJS::AST::ExpressionStatement *>(ast: node))
314 node = exprStmt->expression;
315 QQmlJS::SourceLocation start = node->firstSourceLocation();
316 QQmlJS::SourceLocation end = node->lastSourceLocation();
317 return doc->code.mid(position: start.offset, n: end.offset + end.length - start.offset);
318}
319
320QStringList Signal::parameterStringList(const QV4::Compiler::StringTableGenerator *stringPool) const
321{
322 QStringList result;
323 result.reserve(asize: parameters->count);
324 for (Parameter *param = parameters->first; param; param = param->next)
325 result << stringPool->stringForIndex(index: param->nameIndex);
326 return result;
327}
328
329Document::Document(bool debugMode)
330 : jsModule(debugMode)
331 , program(nullptr)
332 , jsGenerator(&jsModule)
333{
334}
335
336ScriptDirectivesCollector::ScriptDirectivesCollector(Document *doc)
337 : document(doc)
338 , engine(&doc->jsParserEngine)
339 , jsGenerator(&doc->jsGenerator)
340{
341}
342
343void ScriptDirectivesCollector::pragmaLibrary()
344{
345 document->jsModule.unitFlags |= QV4::CompiledData::Unit::IsSharedLibrary;
346}
347
348void ScriptDirectivesCollector::importFile(const QString &jsfile, const QString &module, int lineNumber, int column)
349{
350 QV4::CompiledData::Import *import = engine->pool()->New<QV4::CompiledData::Import>();
351 import->type = QV4::CompiledData::Import::ImportScript;
352 import->uriIndex = jsGenerator->registerString(str: jsfile);
353 import->qualifierIndex = jsGenerator->registerString(str: module);
354 import->location.set(line: lineNumber, column);
355 document->imports << import;
356}
357
358void ScriptDirectivesCollector::importModule(const QString &uri, const QString &version, const QString &module, int lineNumber, int column)
359{
360 QV4::CompiledData::Import *import = engine->pool()->New<QV4::CompiledData::Import>();
361 import->type = QV4::CompiledData::Import::ImportLibrary;
362 import->uriIndex = jsGenerator->registerString(str: uri);
363 import->version = IRBuilder::extractVersion(string: version);
364 import->qualifierIndex = jsGenerator->registerString(str: module);
365 import->location.set(line: lineNumber, column);
366 document->imports << import;
367}
368
369IRBuilder::IRBuilder(const QSet<QString> &illegalNames)
370 : illegalNames(illegalNames)
371 , _object(nullptr)
372 , _propertyDeclaration(nullptr)
373 , pool(nullptr)
374 , jsGenerator(nullptr)
375{
376}
377
378bool IRBuilder::generateFromQml(const QString &code, const QString &url, Document *output)
379{
380 QQmlJS::AST::UiProgram *program = nullptr;
381 {
382 QQmlJS::Lexer lexer(&output->jsParserEngine);
383 lexer.setCode(code, /*line = */ lineno: 1);
384
385 QQmlJS::Parser parser(&output->jsParserEngine);
386
387 const bool parseResult = parser.parse();
388 const auto diagnosticMessages = parser.diagnosticMessages();
389 if (!parseResult || !diagnosticMessages.isEmpty()) {
390 // Extract errors from the parser
391 for (const QQmlJS::DiagnosticMessage &m : diagnosticMessages) {
392 if (m.isWarning()) {
393 qWarning("%s:%d : %s", qPrintable(url), m.loc.startLine, qPrintable(m.message));
394 continue;
395 }
396
397 errors << m;
398 }
399
400 if (!errors.isEmpty() || !parseResult)
401 return false;
402 }
403 program = parser.ast();
404 Q_ASSERT(program);
405 }
406
407 output->code = code;
408 output->program = program;
409
410 qSwap(value1&: _imports, value2&: output->imports);
411 qSwap(value1&: _pragmas, value2&: output->pragmas);
412 qSwap(value1&: _objects, value2&: output->objects);
413 this->pool = output->jsParserEngine.pool();
414 this->jsGenerator = &output->jsGenerator;
415
416 Q_ASSERT(registerString(QString()) == emptyStringIndex);
417
418 sourceCode = code;
419
420 accept(node: program->headers);
421
422 if (program->members->next) {
423 QQmlJS::SourceLocation loc = program->members->next->firstSourceLocation();
424 recordError(location: loc, description: QCoreApplication::translate(context: "QQmlParser", key: "Unexpected object definition"));
425 return false;
426 }
427
428 QQmlJS::AST::UiObjectDefinition *rootObject = QQmlJS::AST::cast<QQmlJS::AST::UiObjectDefinition*>(ast: program->members->member);
429 Q_ASSERT(rootObject);
430 int rootObjectIndex = -1;
431 if (defineQMLObject(objectIndex: &rootObjectIndex, node: rootObject)) {
432 Q_ASSERT(rootObjectIndex == 0);
433 }
434
435 qSwap(value1&: _imports, value2&: output->imports);
436 qSwap(value1&: _pragmas, value2&: output->pragmas);
437 qSwap(value1&: _objects, value2&: output->objects);
438
439 for (auto object: output->objects)
440 object->simplifyRequiredProperties();
441
442 return errors.isEmpty();
443}
444
445bool IRBuilder::visit(QQmlJS::AST::UiArrayMemberList *ast)
446{
447 return QQmlJS::AST::Visitor::visit(ast);
448}
449
450bool IRBuilder::visit(QQmlJS::AST::UiProgram *)
451{
452 Q_ASSERT(!"should not happen");
453 return false;
454}
455
456bool IRBuilder::visit(QQmlJS::AST::UiObjectDefinition *node)
457{
458 // The grammar can't distinguish between two different definitions here:
459 // Item { ... }
460 // versus
461 // font { ... }
462 // The former is a new binding with no property name and "Item" as type name,
463 // and the latter is a binding to the font property with no type name but
464 // only initializer.
465
466 QQmlJS::AST::UiQualifiedId *lastId = node->qualifiedTypeNameId;
467 while (lastId->next)
468 lastId = lastId->next;
469 bool isType = lastId->name.data()->isUpper();
470 if (isType) {
471 int idx = 0;
472 if (!defineQMLObject(objectIndex: &idx, node))
473 return false;
474 const QQmlJS::SourceLocation nameLocation = node->qualifiedTypeNameId->identifierToken;
475 appendBinding(qualifiedNameLocation: nameLocation, nameLocation, propertyNameIndex: emptyStringIndex, objectIndex: idx);
476 } else {
477 int idx = 0;
478 const QQmlJS::SourceLocation location = node->qualifiedTypeNameId->firstSourceLocation();
479 if (!defineQMLObject(
480 objectIndex: &idx, /*qualfied type name id*/qualifiedTypeNameId: nullptr,
481 location: { location.startLine, location.startColumn }, initializer: node->initializer,
482 /*declarations should go here*/declarationsOverride: _object)) {
483 return false;
484 }
485 appendBinding(name: node->qualifiedTypeNameId, objectIndex: idx);
486 }
487 return false;
488}
489
490bool IRBuilder::visit(QQmlJS::AST::UiInlineComponent *ast)
491{
492 int idx = -1;
493 if (insideInlineComponent) {
494 recordError(location: ast->firstSourceLocation(), description: QLatin1String("Nested inline components are not supported"));
495 return false;
496 }
497 if (inlineComponentsNames.contains(value: ast->name.toString())) {
498 recordError(location: ast->firstSourceLocation(), description: QLatin1String("Inline component names must be unique per file"));
499 return false;
500 } else {
501 inlineComponentsNames.insert(value: ast->name.toString());
502 }
503 {
504 QScopedValueRollback<bool> rollBack {insideInlineComponent, true};
505 if (!defineQMLObject(objectIndex: &idx, node: ast->component))
506 return false;
507 }
508 Q_ASSERT(idx > 0);
509 Object* definedObject = _objects.at(i: idx);
510 definedObject->flags |= QV4::CompiledData::Object::IsInlineComponentRoot;
511 definedObject->flags |= QV4::CompiledData::Object::IsPartOfInlineComponent;
512 auto inlineComponent = New<InlineComponent>();
513 inlineComponent->nameIndex = registerString(str: ast->name.toString());
514 inlineComponent->objectIndex = idx;
515 auto location = ast->firstSourceLocation();
516 inlineComponent->location.set(line: location.startLine, column: location.startColumn);
517 _object->appendInlineComponent(ic: inlineComponent);
518 return false;
519}
520
521bool IRBuilder::visit(QQmlJS::AST::UiObjectBinding *node)
522{
523 int idx = 0;
524 const QQmlJS::SourceLocation location = node->qualifiedTypeNameId->firstSourceLocation();
525 if (!defineQMLObject(objectIndex: &idx, qualifiedTypeNameId: node->qualifiedTypeNameId,
526 location: { location.startLine, location.startColumn }, initializer: node->initializer)) {
527 return false;
528 }
529 appendBinding(name: node->qualifiedId, objectIndex: idx, isOnAssignment: node->hasOnToken);
530 return false;
531}
532
533bool IRBuilder::visit(QQmlJS::AST::UiScriptBinding *node)
534{
535 appendBinding(name: node->qualifiedId, value: node->statement, parentNode: node);
536 return false;
537}
538
539bool IRBuilder::visit(QQmlJS::AST::UiArrayBinding *node)
540{
541 const QQmlJS::SourceLocation qualifiedNameLocation = node->qualifiedId->identifierToken;
542 Object *object = nullptr;
543 QQmlJS::AST::UiQualifiedId *name = node->qualifiedId;
544 if (!resolveQualifiedId(nameToResolve: &name, object: &object))
545 return false;
546
547 qSwap(value1&: _object, value2&: object);
548
549 const int propertyNameIndex = registerString(str: name->name.toString());
550
551 if (bindingsTarget()->findBinding(nameIndex: propertyNameIndex) != nullptr) {
552 recordError(location: name->identifierToken, description: tr(sourceText: "Property value set multiple times"));
553 return false;
554 }
555
556 QVarLengthArray<QQmlJS::AST::UiArrayMemberList *, 16> memberList;
557 QQmlJS::AST::UiArrayMemberList *member = node->members;
558 while (member) {
559 memberList.append(t: member);
560 member = member->next;
561 }
562 for (int i = memberList.size() - 1; i >= 0; --i) {
563 member = memberList.at(idx: i);
564 QQmlJS::AST::UiObjectDefinition *def = QQmlJS::AST::cast<QQmlJS::AST::UiObjectDefinition*>(ast: member->member);
565
566 int idx = 0;
567 if (!defineQMLObject(objectIndex: &idx, node: def))
568 return false;
569 appendBinding(qualifiedNameLocation, nameLocation: name->identifierToken, propertyNameIndex, objectIndex: idx, /*isListItem*/ true);
570 }
571
572 qSwap(value1&: _object, value2&: object);
573 return false;
574}
575
576bool IRBuilder::visit(QQmlJS::AST::UiHeaderItemList *list)
577{
578 return QQmlJS::AST::Visitor::visit(list);
579}
580
581bool IRBuilder::visit(QQmlJS::AST::UiObjectInitializer *ast)
582{
583 return QQmlJS::AST::Visitor::visit(ast);
584}
585
586bool IRBuilder::visit(QQmlJS::AST::UiObjectMemberList *ast)
587{
588 return QQmlJS::AST::Visitor::visit(ast);
589}
590
591bool IRBuilder::visit(QQmlJS::AST::UiParameterList *ast)
592{
593 return QQmlJS::AST::Visitor::visit(ast);
594}
595
596bool IRBuilder::visit(QQmlJS::AST::UiQualifiedId *id)
597{
598 return QQmlJS::AST::Visitor::visit(id);
599}
600
601void IRBuilder::accept(QQmlJS::AST::Node *node)
602{
603 QQmlJS::AST::Node::accept(node, visitor: this);
604}
605
606bool IRBuilder::defineQMLObject(
607 int *objectIndex, QQmlJS::AST::UiQualifiedId *qualifiedTypeNameId,
608 const QV4::CompiledData::Location &location, QQmlJS::AST::UiObjectInitializer *initializer,
609 Object *declarationsOverride)
610{
611 if (QQmlJS::AST::UiQualifiedId *lastName = qualifiedTypeNameId) {
612 while (lastName->next)
613 lastName = lastName->next;
614 if (!lastName->name.constData()->isUpper()) {
615 recordError(location: lastName->identifierToken, description: tr(sourceText: "Expected type name"));
616 return false;
617 }
618 }
619
620 Object *obj = New<Object>();
621
622 _objects.append(t: obj);
623 *objectIndex = _objects.size() - 1;
624 qSwap(value1&: _object, value2&: obj);
625
626 _object->init(pool, typeNameIndex: registerString(str: asString(node: qualifiedTypeNameId)), idIndex: emptyStringIndex, loc: location);
627 _object->declarationsOverride = declarationsOverride;
628 if (insideInlineComponent) {
629 _object->flags |= QV4::CompiledData::Object::IsPartOfInlineComponent;
630 }
631
632 // A new object is also a boundary for property declarations.
633 Property *declaration = nullptr;
634 qSwap(value1&: _propertyDeclaration, value2&: declaration);
635
636 accept(node: initializer);
637
638 qSwap(value1&: _propertyDeclaration, value2&: declaration);
639
640 qSwap(value1&: _object, value2&: obj);
641
642 if (!errors.isEmpty())
643 return false;
644
645 QQmlJS::SourceLocation loc;
646 QString error = sanityCheckFunctionNames(obj, illegalNames, errorLocation: &loc);
647 if (!error.isEmpty()) {
648 recordError(location: loc, description: error);
649 return false;
650 }
651
652 return true;
653}
654
655bool IRBuilder::visit(QQmlJS::AST::UiImport *node)
656{
657 QString uri;
658 QV4::CompiledData::Import *import = New<QV4::CompiledData::Import>();
659
660 if (!node->fileName.isNull()) {
661 uri = node->fileName.toString();
662
663 if (uri.endsWith(s: QLatin1String(".js")) || uri.endsWith(s: QLatin1String(".mjs"))) {
664 import->type = QV4::CompiledData::Import::ImportScript;
665 } else {
666 import->type = QV4::CompiledData::Import::ImportFile;
667 }
668 } else {
669 import->type = QV4::CompiledData::Import::ImportLibrary;
670 uri = asString(node: node->importUri);
671 }
672
673 import->qualifierIndex = emptyStringIndex;
674
675 // Qualifier
676 if (!node->importId.isNull()) {
677 QString qualifier = node->importId.toString();
678 if (!qualifier.at(i: 0).isUpper()) {
679 recordError(location: node->importIdToken, description: QCoreApplication::translate(context: "QQmlParser",key: "Invalid import qualifier ID"));
680 return false;
681 }
682 if (qualifier == QLatin1String("Qt")) {
683 recordError(location: node->importIdToken, description: QCoreApplication::translate(context: "QQmlParser",key: "Reserved name \"Qt\" cannot be used as an qualifier"));
684 return false;
685 }
686 import->qualifierIndex = registerString(str: qualifier);
687
688 // Check for script qualifier clashes
689 bool isScript = import->type == QV4::CompiledData::Import::ImportScript;
690 for (int ii = 0; ii < _imports.size(); ++ii) {
691 const QV4::CompiledData::Import *other = _imports.at(i: ii);
692 bool otherIsScript = other->type == QV4::CompiledData::Import::ImportScript;
693
694 if ((isScript || otherIsScript) && qualifier == jsGenerator->stringForIndex(index: other->qualifierIndex)) {
695 recordError(location: node->importIdToken, description: QCoreApplication::translate(context: "QQmlParser",key: "Script import qualifiers must be unique."));
696 return false;
697 }
698 }
699
700 } else if (import->type == QV4::CompiledData::Import::ImportScript) {
701 recordError(location: node->fileNameToken, description: QCoreApplication::translate(context: "QQmlParser",key: "Script import requires a qualifier"));
702 return false;
703 }
704
705 if (node->version) {
706 import->version = node->version->version;
707 } else {
708 // Otherwise initialize the major and minor version to invalid to signal "latest".
709 import->version = QTypeRevision();
710 }
711
712 import->location.set(line: node->importToken.startLine, column: node->importToken.startColumn);
713
714 import->uriIndex = registerString(str: uri);
715
716 _imports.append(t: import);
717
718 return false;
719}
720
721
722template<typename Argument>
723struct PragmaParser
724{
725 static bool run(IRBuilder *builder, QQmlJS::AST::UiPragma *node, Pragma *pragma)
726 {
727 Q_ASSERT(builder);
728 Q_ASSERT(node);
729 Q_ASSERT(pragma);
730
731 if (!isUnique(builder)) {
732 builder->recordError(
733 location: node->pragmaToken, description: QCoreApplication::translate(
734 context: "QQmlParser", key: "Multiple %1 pragmas found").arg(a: name()));
735 return false;
736 }
737
738 pragma->type = type();
739
740 if (QQmlJS::AST::UiPragmaValueList *bad = assign(pragma, values: node->values)) {
741 builder->recordError(
742 location: node->pragmaToken, description: QCoreApplication::translate(
743 context: "QQmlParser", key: "Unknown %1 '%2' in pragma").arg(args: name(), args&: bad->value));
744 return false;
745 }
746
747 return true;
748 }
749
750private:
751 static constexpr Pragma::PragmaType type()
752 {
753 if constexpr (std::is_same_v<Argument, Pragma::ComponentBehaviorValue>) {
754 return Pragma::ComponentBehavior;
755 } else if constexpr (std::is_same_v<Argument, Pragma::ListPropertyAssignBehaviorValue>) {
756 return Pragma::ListPropertyAssignBehavior;
757 } else if constexpr (std::is_same_v<Argument, Pragma::FunctionSignatureBehaviorValue>) {
758 return Pragma::FunctionSignatureBehavior;
759 } else if constexpr (std::is_same_v<Argument, Pragma::NativeMethodBehaviorValue>) {
760 return Pragma::NativeMethodBehavior;
761 } else if constexpr (std::is_same_v<Argument, Pragma::ValueTypeBehaviorValue>) {
762 return Pragma::ValueTypeBehavior;
763 }
764
765 Q_UNREACHABLE_RETURN(Pragma::PragmaType(-1));
766 }
767
768 template<typename F>
769 static QQmlJS::AST::UiPragmaValueList *iterateValues(
770 QQmlJS::AST::UiPragmaValueList *input, F &&process)
771 {
772 for (QQmlJS::AST::UiPragmaValueList *i = input; i; i = i->next) {
773 if (!process(i->value))
774 return i;
775 }
776 return nullptr;
777 }
778
779 static QQmlJS::AST::UiPragmaValueList *assign(
780 Pragma *pragma, QQmlJS::AST::UiPragmaValueList *values)
781 {
782 // We could use QMetaEnum here to make the code more compact,
783 // but it's probably more expensive.
784
785 if constexpr (std::is_same_v<Argument, Pragma::ComponentBehaviorValue>) {
786 return iterateValues(values, [pragma](QStringView value) {
787 if (value == "Unbound"_L1) {
788 pragma->componentBehavior = Pragma::Unbound;
789 return true;
790 }
791 if (value == "Bound"_L1) {
792 pragma->componentBehavior = Pragma::Bound;
793 return true;
794 }
795 return false;
796 });
797 } else if constexpr (std::is_same_v<Argument, Pragma::ListPropertyAssignBehaviorValue>) {
798 return iterateValues(values, [pragma](QStringView value) {
799 if (value == "Append"_L1) {
800 pragma->listPropertyAssignBehavior = Pragma::Append;
801 return true;
802 }
803 if (value == "Replace"_L1) {
804 pragma->listPropertyAssignBehavior = Pragma::Replace;
805 return true;
806 }
807 if (value == "ReplaceIfNotDefault"_L1) {
808 pragma->listPropertyAssignBehavior = Pragma::ReplaceIfNotDefault;
809 return true;
810 }
811 return false;
812 });
813 } else if constexpr (std::is_same_v<Argument, Pragma::FunctionSignatureBehaviorValue>) {
814 return iterateValues(values, [pragma](QStringView value) {
815 if (value == "Ignored"_L1) {
816 pragma->functionSignatureBehavior = Pragma::Ignored;
817 return true;
818 }
819 if (value == "Enforced"_L1) {
820 pragma->functionSignatureBehavior = Pragma::Enforced;
821 return true;
822 }
823 return false;
824 });
825 } else if constexpr (std::is_same_v<Argument, Pragma::NativeMethodBehaviorValue>) {
826 return iterateValues(values, [pragma](QStringView value) {
827 if (value == "AcceptThisObject"_L1) {
828 pragma->nativeMethodBehavior = Pragma::AcceptThisObject;
829 return true;
830 }
831 if (value == "RejectThisObject"_L1) {
832 pragma->nativeMethodBehavior = Pragma::RejectThisObject;
833 return true;
834 }
835 return false;
836 });
837 } else if constexpr (std::is_same_v<Argument, Pragma::ValueTypeBehaviorValue>) {
838 pragma->valueTypeBehavior = Pragma::ValueTypeBehaviorValues().toInt();
839 return iterateValues(values, [pragma](QStringView value) {
840 const auto setFlag = [pragma](Pragma::ValueTypeBehaviorValue flag, bool value) {
841 pragma->valueTypeBehavior
842 = Pragma::ValueTypeBehaviorValues(pragma->valueTypeBehavior)
843 .setFlag(flag, on: value).toInt();
844 };
845
846 if (value == "Reference"_L1) {
847 setFlag(Pragma::Copy, false);
848 return true;
849 }
850 if (value == "Copy"_L1) {
851 setFlag(Pragma::Copy, true);
852 return true;
853 }
854
855 if (value == "Inaddressable"_L1) {
856 setFlag(Pragma::Addressable, false);
857 return true;
858 }
859 if (value == "Addressable"_L1) {
860 setFlag(Pragma::Addressable, true);
861 return true;
862 }
863
864 if (value == "Inassertable"_L1) {
865 setFlag(Pragma::Assertable, false);
866 return true;
867 }
868 if (value == "Assertable"_L1) {
869 setFlag(Pragma::Assertable, true);
870 return true;
871 }
872
873 return false;
874 });
875 }
876
877 Q_UNREACHABLE_RETURN(nullptr);
878 }
879
880 static bool isUnique(IRBuilder *builder)
881 {
882 for (const Pragma *prev : builder->_pragmas) {
883 if (prev->type == type())
884 return false;
885 }
886 return true;
887 };
888
889 static QLatin1StringView name()
890 {
891 switch (type()) {
892 case Pragma::ListPropertyAssignBehavior:
893 return "list property assign behavior"_L1;
894 case Pragma::ComponentBehavior:
895 return "component behavior"_L1;
896 case Pragma::FunctionSignatureBehavior:
897 return "function signature behavior"_L1;
898 case Pragma::NativeMethodBehavior:
899 return "native method behavior"_L1;
900 case Pragma::ValueTypeBehavior:
901 return "value type behavior"_L1;
902 default:
903 break;
904 }
905 Q_UNREACHABLE_RETURN(QLatin1StringView());
906 }
907};
908
909bool IRBuilder::visit(QQmlJS::AST::UiPragma *node)
910{
911 Pragma *pragma = New<Pragma>();
912
913 if (!node->name.isNull()) {
914 if (node->name == "Singleton"_L1) {
915 pragma->type = Pragma::Singleton;
916 } else if (node->name == "Strict"_L1) {
917 pragma->type = Pragma::Strict;
918 } else if (node->name == "ComponentBehavior"_L1) {
919 if (!PragmaParser<Pragma::ComponentBehaviorValue>::run(builder: this, node, pragma))
920 return false;
921 } else if (node->name == "ListPropertyAssignBehavior"_L1) {
922 if (!PragmaParser<Pragma::ListPropertyAssignBehaviorValue>::run(builder: this, node, pragma))
923 return false;
924 } else if (node->name == "FunctionSignatureBehavior"_L1) {
925 if (!PragmaParser<Pragma::FunctionSignatureBehaviorValue>::run(builder: this, node, pragma))
926 return false;
927 } else if (node->name == "NativeMethodBehavior"_L1) {
928 if (!PragmaParser<Pragma::NativeMethodBehaviorValue>::run(builder: this, node, pragma))
929 return false;
930 } else if (node->name == "ValueTypeBehavior"_L1) {
931 if (!PragmaParser<Pragma::ValueTypeBehaviorValue>::run(builder: this, node, pragma))
932 return false;
933 } else if (node->name == "Translator"_L1) {
934 pragma->type = Pragma::Translator;
935 pragma->translationContextIndex = registerString(str: node->values->value.toString());
936
937 } else {
938 recordError(location: node->pragmaToken, description: QCoreApplication::translate(
939 context: "QQmlParser", key: "Unknown pragma '%1'").arg(a: node->name));
940 return false;
941 }
942 } else {
943 recordError(location: node->pragmaToken, description: QCoreApplication::translate(
944 context: "QQmlParser", key: "Empty pragma found"));
945 return false;
946 }
947
948 pragma->location.set(line: node->pragmaToken.startLine, column: node->pragmaToken.startColumn);
949 _pragmas.append(t: pragma);
950
951 return false;
952}
953
954static QStringList astNodeToStringList(QQmlJS::AST::Node *node)
955{
956 if (node->kind == QQmlJS::AST::Node::Kind_IdentifierExpression) {
957 QString name =
958 static_cast<QQmlJS::AST::IdentifierExpression *>(node)->name.toString();
959 return QStringList() << name;
960 } else if (node->kind == QQmlJS::AST::Node::Kind_FieldMemberExpression) {
961 QQmlJS::AST::FieldMemberExpression *expr = static_cast<QQmlJS::AST::FieldMemberExpression *>(node);
962
963 QStringList rv = astNodeToStringList(node: expr->base);
964 if (rv.isEmpty())
965 return rv;
966 rv.append(t: expr->name.toString());
967 return rv;
968 }
969 return QStringList();
970}
971
972bool IRBuilder::visit(QQmlJS::AST::UiEnumDeclaration *node)
973{
974 Enum *enumeration = New<Enum>();
975 QString enumName = node->name.toString();
976 enumeration->nameIndex = registerString(str: enumName);
977
978 if (enumName.at(i: 0).isLower())
979 COMPILE_EXCEPTION(node->enumToken, tr("Scoped enum names must begin with an upper case letter"));
980
981 enumeration->location.set(line: node->enumToken.startLine, column: node->enumToken.startColumn);
982
983 enumeration->enumValues = New<PoolList<EnumValue>>();
984
985 QQmlJS::AST::UiEnumMemberList *e = node->members;
986 while (e) {
987 EnumValue *enumValue = New<EnumValue>();
988 QString member = e->member.toString();
989 enumValue->nameIndex = registerString(str: member);
990 if (member.at(i: 0).isLower())
991 COMPILE_EXCEPTION(e->memberToken, tr("Enum names must begin with an upper case letter"));
992
993 double part;
994 if (std::modf(x: e->value, iptr: &part) != 0.0)
995 COMPILE_EXCEPTION(e->valueToken, tr("Enum value must be an integer"));
996 if (e->value > std::numeric_limits<qint32>::max() || e->value < std::numeric_limits<qint32>::min())
997 COMPILE_EXCEPTION(e->valueToken, tr("Enum value out of range"));
998 enumValue->value = e->value;
999
1000 enumValue->location.set(line: e->memberToken.startLine, column: e->memberToken.startColumn);
1001 enumeration->enumValues->append(item: enumValue);
1002
1003 e = e->next;
1004 }
1005
1006 QString error = _object->appendEnum(enumeration);
1007 if (!error.isEmpty()) {
1008 recordError(location: node->enumToken, description: error);
1009 return false;
1010 }
1011
1012 return false;
1013}
1014
1015
1016bool IRBuilder::visit(QQmlJS::AST::UiPublicMember *node)
1017{
1018 if (node->type == QQmlJS::AST::UiPublicMember::Signal) {
1019 Signal *signal = New<Signal>();
1020 const QString signalName = node->name.toString();
1021 signal->nameIndex = registerString(str: signalName);
1022
1023 QQmlJS::SourceLocation loc = node->typeToken;
1024 signal->location.set(line: loc.startLine, column: loc.startColumn);
1025
1026 signal->parameters = New<PoolList<Parameter> >();
1027
1028 QQmlJS::AST::UiParameterList *p = node->parameters;
1029 while (p) {
1030 if (!p->type) {
1031 recordError(location: node->typeToken, description: QCoreApplication::translate(context: "QQmlParser",key: "Expected parameter type"));
1032 return false;
1033 }
1034
1035 Parameter *param = New<Parameter>();
1036 param->nameIndex = registerString(str: p->name.toString());
1037 if (!Parameter::initType(
1038 type: &param->type, idGenerator: [this](const QString &str) { return registerString(str); },
1039 annotation: p->type)) {
1040 QString errStr = QCoreApplication::translate(context: "QQmlParser",key: "Invalid signal parameter type: ");
1041 errStr.append(s: p->type->toString());
1042 recordError(location: node->typeToken, description: errStr);
1043 return false;
1044 }
1045 signal->parameters->append(item: param);
1046 p = p->next;
1047 }
1048
1049 for (const QChar &ch : signalName) {
1050 if (ch.isLower())
1051 break;
1052 if (ch.isUpper()) {
1053 COMPILE_EXCEPTION(node->identifierToken,
1054 tr("Signal names cannot begin with an upper case letter"));
1055 }
1056 }
1057
1058 if (illegalNames.contains(value: signalName))
1059 COMPILE_EXCEPTION(node->identifierToken, tr("Illegal signal name"));
1060
1061 QString error = _object->appendSignal(signal);
1062 if (!error.isEmpty()) {
1063 recordError(location: node->identifierToken, description: error);
1064 return false;
1065 }
1066 } else {
1067 QString memberType = asString(node: node->memberType);
1068 if (memberType == QLatin1String("alias")) {
1069 return appendAlias(node);
1070 } else {
1071 QStringView name = node->name;
1072
1073 Property *property = New<Property>();
1074 property->setIsReadOnly(node->isReadonly());
1075 property->setIsRequired(node->isRequired());
1076
1077 const QV4::CompiledData::CommonType builtinPropertyType
1078 = Parameter::stringToBuiltinType(typeName: memberType);
1079 if (builtinPropertyType != QV4::CompiledData::CommonType::Invalid)
1080 property->setCommonType(builtinPropertyType);
1081 else
1082 property->setTypeNameIndex(registerString(str: memberType));
1083
1084 QStringView typeModifier = node->typeModifier;
1085 if (typeModifier == QLatin1String("list")) {
1086 property->setIsList(true);
1087 } else if (!typeModifier.isEmpty()) {
1088 recordError(location: node->typeModifierToken, description: QCoreApplication::translate(context: "QQmlParser",key: "Invalid property type modifier"));
1089 return false;
1090 }
1091
1092 const QString propName = name.toString();
1093 property->nameIndex = registerString(str: propName);
1094
1095 QQmlJS::SourceLocation loc = node->firstSourceLocation();
1096 property->location.set(line: loc.startLine, column: loc.startColumn);
1097
1098 QQmlJS::SourceLocation errorLocation;
1099 QString error;
1100
1101 if (illegalNames.contains(value: propName))
1102 error = tr(sourceText: "Illegal property name");
1103 else
1104 error = _object->appendProperty(prop: property, propertyName: propName, isDefaultProperty: node->isDefaultMember(), defaultToken: node->defaultToken(), errorLocation: &errorLocation);
1105
1106 if (!error.isEmpty()) {
1107 if (errorLocation.startLine == 0)
1108 errorLocation = node->identifierToken;
1109
1110 recordError(location: errorLocation, description: error);
1111 return false;
1112 }
1113
1114 qSwap(value1&: _propertyDeclaration, value2&: property);
1115 if (node->binding) {
1116 // process QML-like initializers (e.g. property Object o: Object {})
1117 QQmlJS::AST::Node::accept(node: node->binding, visitor: this);
1118 } else if (node->statement) {
1119 if (!isRedundantNullInitializerForPropertyDeclaration(property: _propertyDeclaration, statement: node->statement))
1120 appendBinding(qualifiedNameLocation: node->identifierToken, nameLocation: node->identifierToken, propertyNameIndex: _propertyDeclaration->nameIndex, value: node->statement, parentNode: node);
1121 }
1122 qSwap(value1&: _propertyDeclaration, value2&: property);
1123 }
1124 }
1125
1126 return false;
1127}
1128
1129bool IRBuilder::visit(QQmlJS::AST::UiSourceElement *node)
1130{
1131 if (QQmlJS::AST::FunctionExpression *funDecl = node->sourceElement->asFunctionDefinition()) {
1132 if (_object->declarationsOverride) {
1133 // See Object::appendFunction() for why.
1134 recordError(location: node->firstSourceLocation(),
1135 description: QCoreApplication::translate(
1136 context: "QQmlParser", key: "Function declaration inside grouped property"));
1137 return false;
1138 }
1139
1140 CompiledFunctionOrExpression *foe = New<CompiledFunctionOrExpression>();
1141 foe->node = funDecl;
1142 foe->parentNode = funDecl;
1143 foe->nameIndex = registerString(str: funDecl->name.toString());
1144 const int index = _object->functionsAndExpressions->append(item: foe);
1145
1146 Function *f = New<Function>();
1147 QQmlJS::SourceLocation loc = funDecl->identifierToken;
1148 f->location.set(line: loc.startLine, column: loc.startColumn);
1149 f->index = index;
1150 f->nameIndex = registerString(str: funDecl->name.toString());
1151
1152 const auto idGenerator = [this](const QString &str) { return registerString(str); };
1153
1154 Parameter::initType(
1155 type: &f->returnType, idGenerator,
1156 annotation: funDecl->typeAnnotation ? funDecl->typeAnnotation->type : nullptr);
1157
1158 const QQmlJS::AST::BoundNames formals = funDecl->formals ? funDecl->formals->formals() : QQmlJS::AST::BoundNames();
1159 int formalsCount = formals.size();
1160 f->formals.allocate(pool, size: formalsCount);
1161
1162 int i = 0;
1163 for (const auto &arg : formals) {
1164 Parameter *functionParameter = &f->formals[i];
1165 functionParameter->nameIndex = registerString(str: arg.id);
1166 Parameter::initType(
1167 type: &functionParameter->type, idGenerator,
1168 annotation: arg.typeAnnotation.isNull() ? nullptr : arg.typeAnnotation->type);
1169 ++i;
1170 }
1171
1172 _object->appendFunction(f);
1173 } else {
1174 recordError(location: node->firstSourceLocation(), description: QCoreApplication::translate(context: "QQmlParser",key: "JavaScript declaration outside Script element"));
1175 }
1176 return false;
1177}
1178
1179bool IRBuilder::visit(AST::UiRequired *ast)
1180{
1181 auto extraData = New<RequiredPropertyExtraData>();
1182 extraData->nameIndex = registerString(str: ast->name.toString());
1183 _object->appendRequiredPropertyExtraData(extraData);
1184 return false;
1185}
1186
1187QString IRBuilder::asString(QQmlJS::AST::UiQualifiedId *node)
1188{
1189 QString s;
1190
1191 for (QQmlJS::AST::UiQualifiedId *it = node; it; it = it->next) {
1192 s.append(v: it->name);
1193
1194 if (it->next)
1195 s.append(c: QLatin1Char('.'));
1196 }
1197
1198 return s;
1199}
1200
1201QStringView IRBuilder::asStringRef(QQmlJS::AST::Node *node)
1202{
1203 if (!node)
1204 return QStringView();
1205
1206 return textRefAt(first: node->firstSourceLocation(), last: node->lastSourceLocation());
1207}
1208
1209QTypeRevision IRBuilder::extractVersion(QStringView string)
1210{
1211 if (string.isEmpty())
1212 return QTypeRevision();
1213
1214 const int dot = string.indexOf(c: QLatin1Char('.'));
1215 return (dot < 0)
1216 ? QTypeRevision::fromMajorVersion(majorVersion: string.toInt())
1217 : QTypeRevision::fromVersion(majorVersion: string.left(n: dot).toInt(), minorVersion: string.mid(pos: dot + 1).toInt());
1218}
1219
1220QStringView IRBuilder::textRefAt(const QQmlJS::SourceLocation &first, const QQmlJS::SourceLocation &last) const
1221{
1222 return QStringView(sourceCode).mid(pos: first.offset, n: last.offset + last.length - first.offset);
1223}
1224
1225void IRBuilder::setBindingValue(QV4::CompiledData::Binding *binding, QQmlJS::AST::Statement *statement, QQmlJS::AST::Node *parentNode)
1226{
1227 QQmlJS::SourceLocation loc = statement->firstSourceLocation();
1228 binding->valueLocation.set(line: loc.startLine, column: loc.startColumn);
1229 binding->setType(QV4::CompiledData::Binding::Type_Invalid);
1230 if (_propertyDeclaration && _propertyDeclaration->isReadOnly())
1231 binding->setFlag(QV4::CompiledData::Binding::InitializerForReadOnlyDeclaration);
1232
1233 QQmlJS::AST::ExpressionStatement *exprStmt = QQmlJS::AST::cast<QQmlJS::AST::ExpressionStatement *>(ast: statement);
1234 if (exprStmt) {
1235 QQmlJS::AST::ExpressionNode * const expr = exprStmt->expression;
1236 if (QQmlJS::AST::StringLiteral *lit = QQmlJS::AST::cast<QQmlJS::AST::StringLiteral *>(ast: expr)) {
1237 binding->setType(QV4::CompiledData::Binding::Type_String);
1238 binding->stringIndex = registerString(str: lit->value.toString());
1239 } else if (QQmlJS::AST::TemplateLiteral *templateLit = QQmlJS::AST::cast<QQmlJS::AST::TemplateLiteral *>(ast: expr);
1240 templateLit && templateLit->hasNoSubstitution) {
1241 // A template literal without substitution is just a string.
1242 // With substitution, it could however be an arbitrarily complex expression
1243 binding->setType(QV4::CompiledData::Binding::Type_String);
1244 binding->stringIndex = registerString(str: templateLit->value.toString());
1245 } else if (expr->kind == QQmlJS::AST::Node::Kind_TrueLiteral) {
1246 binding->setType(QV4::CompiledData::Binding::Type_Boolean);
1247 binding->value.b = true;
1248 } else if (expr->kind == QQmlJS::AST::Node::Kind_FalseLiteral) {
1249 binding->setType(QV4::CompiledData::Binding::Type_Boolean);
1250 binding->value.b = false;
1251 } else if (QQmlJS::AST::NumericLiteral *lit = QQmlJS::AST::cast<QQmlJS::AST::NumericLiteral *>(ast: expr)) {
1252 binding->setType(QV4::CompiledData::Binding::Type_Number);
1253 binding->value.constantValueIndex = jsGenerator->registerConstant(v: QV4::Encode(lit->value));
1254 } else if (QQmlJS::AST::CallExpression *call = QQmlJS::AST::cast<QQmlJS::AST::CallExpression *>(ast: expr)) {
1255 if (QQmlJS::AST::IdentifierExpression *base = QQmlJS::AST::cast<QQmlJS::AST::IdentifierExpression *>(ast: call->base)) {
1256 tryGeneratingTranslationBinding(base: base->name, args: call->arguments, binding);
1257 // If it wasn't a translation binding, a normal script binding will be generated
1258 // below.
1259 }
1260 } else if (QQmlJS::AST::cast<QQmlJS::AST::FunctionExpression *>(ast: expr)) {
1261 binding->setFlag(QV4::CompiledData::Binding::IsFunctionExpression);
1262 } else if (QQmlJS::AST::UnaryMinusExpression *unaryMinus = QQmlJS::AST::cast<QQmlJS::AST::UnaryMinusExpression *>(ast: expr)) {
1263 if (QQmlJS::AST::NumericLiteral *lit = QQmlJS::AST::cast<QQmlJS::AST::NumericLiteral *>(ast: unaryMinus->expression)) {
1264 binding->setType(QV4::CompiledData::Binding::Type_Number);
1265 binding->value.constantValueIndex = jsGenerator->registerConstant(v: QV4::Encode(-lit->value));
1266 }
1267 } else if (QQmlJS::AST::cast<QQmlJS::AST::NullExpression *>(ast: expr)) {
1268 binding->setType(QV4::CompiledData::Binding::Type_Null);
1269 binding->value.nullMarker = 0;
1270 }
1271 }
1272
1273 // Do binding instead
1274 if (binding->type() == QV4::CompiledData::Binding::Type_Invalid) {
1275 binding->setType(QV4::CompiledData::Binding::Type_Script);
1276
1277 CompiledFunctionOrExpression *expr = New<CompiledFunctionOrExpression>();
1278 expr->node = statement;
1279 expr->parentNode = parentNode;
1280 expr->nameIndex = registerString(str: QLatin1String("expression for ")
1281 + stringAt(index: binding->propertyNameIndex));
1282 const int index = bindingsTarget()->functionsAndExpressions->append(item: expr);
1283 binding->value.compiledScriptIndex = index;
1284 // We don't need to store the binding script as string, except for script strings
1285 // and types with custom parsers. Those will be added later in the compilation phase.
1286 // Except that we cannot recover the string when cachegen runs; we need to therefore retain
1287 // "undefined". Any other "special" strings (for the various literals) are already handled above
1288 QQmlJS::AST::Node *nodeForString = statement;
1289 if (exprStmt)
1290 nodeForString = exprStmt->expression;
1291 if (asStringRef(node: nodeForString) == u"undefined")
1292 binding->stringIndex = registerString(str: u"undefined"_s);
1293 else
1294 binding->stringIndex = emptyStringIndex;
1295 }
1296}
1297
1298void IRBuilder::tryGeneratingTranslationBinding(QStringView base, AST::ArgumentList *args, QV4::CompiledData::Binding *binding)
1299{
1300 const auto registerString = [&](QStringView string) {
1301 return jsGenerator->registerString(str: string.toString()) ;
1302 };
1303
1304 const auto finalizeTranslationData = [&](
1305 QV4::CompiledData::Binding::Type type,
1306 QV4::CompiledData::TranslationData translationData) {
1307 binding->setType(type);
1308 if (type == QV4::CompiledData::Binding::Type_Translation
1309 || type == QV4::CompiledData::Binding::Type_TranslationById) {
1310 binding->value.translationDataIndex = jsGenerator->registerTranslation(translation: translationData);
1311 } else if (type == QV4::CompiledData::Binding::Type_String) {
1312 binding->stringIndex = translationData.number;
1313 }
1314 };
1315
1316 tryGeneratingTranslationBindingBase(
1317 base, args,
1318 registerMainString: registerString, registerCommentString: registerString, registerContextString: registerString, finalizeTranslationData);
1319}
1320
1321void IRBuilder::appendBinding(QQmlJS::AST::UiQualifiedId *name, QQmlJS::AST::Statement *value, QQmlJS::AST::Node *parentNode)
1322{
1323 const QQmlJS::SourceLocation qualifiedNameLocation = name->identifierToken;
1324 Object *object = nullptr;
1325 if (!resolveQualifiedId(nameToResolve: &name, object: &object))
1326 return;
1327 if (_object == object && name->name == QLatin1String("id")) {
1328 setId(idLocation: name->identifierToken, value);
1329 return;
1330 }
1331 qSwap(value1&: _object, value2&: object);
1332 appendBinding(qualifiedNameLocation, nameLocation: name->identifierToken, propertyNameIndex: registerString(str: name->name.toString()), value, parentNode);
1333 qSwap(value1&: _object, value2&: object);
1334}
1335
1336void IRBuilder::appendBinding(QQmlJS::AST::UiQualifiedId *name, int objectIndex, bool isOnAssignment)
1337{
1338 const QQmlJS::SourceLocation qualifiedNameLocation = name->identifierToken;
1339 Object *object = nullptr;
1340 if (!resolveQualifiedId(nameToResolve: &name, object: &object, onAssignment: isOnAssignment))
1341 return;
1342 qSwap(value1&: _object, value2&: object);
1343 appendBinding(qualifiedNameLocation, nameLocation: name->identifierToken, propertyNameIndex: registerString(str: name->name.toString()), objectIndex, /*isListItem*/false, isOnAssignment);
1344 qSwap(value1&: _object, value2&: object);
1345}
1346
1347void IRBuilder::appendBinding(const QQmlJS::SourceLocation &qualifiedNameLocation, const QQmlJS::SourceLocation &nameLocation, quint32 propertyNameIndex,
1348 QQmlJS::AST::Statement *value, QQmlJS::AST::Node *parentNode)
1349{
1350 Binding *binding = New<Binding>();
1351 binding->propertyNameIndex = propertyNameIndex;
1352 binding->offset = nameLocation.offset;
1353 binding->location.set(line: nameLocation.startLine, column: nameLocation.startColumn);
1354 binding->clearFlags();
1355 setBindingValue(binding, statement: value, parentNode);
1356 QString error = bindingsTarget()->appendBinding(b: binding, /*isListBinding*/false);
1357 if (!error.isEmpty()) {
1358 recordError(location: qualifiedNameLocation, description: error);
1359 }
1360}
1361
1362void IRBuilder::appendBinding(const QQmlJS::SourceLocation &qualifiedNameLocation, const QQmlJS::SourceLocation &nameLocation, quint32 propertyNameIndex, int objectIndex, bool isListItem, bool isOnAssignment)
1363{
1364 if (stringAt(index: propertyNameIndex) == QLatin1String("id")) {
1365 recordError(location: nameLocation, description: tr(sourceText: "Invalid component id specification"));
1366 return;
1367 }
1368
1369 Binding *binding = New<Binding>();
1370 binding->propertyNameIndex = propertyNameIndex;
1371 binding->offset = nameLocation.offset;
1372 binding->location.set(line: nameLocation.startLine, column: nameLocation.startColumn);
1373
1374 const Object *obj = _objects.at(i: objectIndex);
1375 binding->valueLocation = obj->location;
1376
1377 binding->clearFlags();
1378
1379 if (_propertyDeclaration && _propertyDeclaration->isReadOnly())
1380 binding->setFlag(Binding::InitializerForReadOnlyDeclaration);
1381
1382 // No type name on the initializer means it must be a group property
1383 if (_objects.at(i: objectIndex)->inheritedTypeNameIndex == emptyStringIndex)
1384 binding->setType(Binding::Type_GroupProperty);
1385 else
1386 binding->setType(Binding::Type_Object);
1387
1388 if (isOnAssignment)
1389 binding->setFlag(Binding::IsOnAssignment);
1390 if (isListItem)
1391 binding->setFlag(Binding::IsListItem);
1392
1393 binding->value.objectIndex = objectIndex;
1394 QString error = bindingsTarget()->appendBinding(b: binding, isListBinding: isListItem);
1395 if (!error.isEmpty()) {
1396 recordError(location: qualifiedNameLocation, description: error);
1397 }
1398}
1399
1400bool IRBuilder::appendAlias(QQmlJS::AST::UiPublicMember *node)
1401{
1402 Alias *alias = New<Alias>();
1403 alias->clearFlags();
1404 if (node->isReadonly())
1405 alias->setFlag(QV4::CompiledData::Alias::IsReadOnly);
1406
1407 const QString propName = node->name.toString();
1408 alias->setNameIndex(registerString(str: propName));
1409
1410 QQmlJS::SourceLocation loc = node->firstSourceLocation();
1411 alias->location.set(line: loc.startLine, column: loc.startColumn);
1412
1413 alias->propertyNameIndex = emptyStringIndex;
1414
1415 if (!node->statement && !node->binding)
1416 COMPILE_EXCEPTION(loc, tr("No property alias location"));
1417
1418 QQmlJS::SourceLocation rhsLoc;
1419 if (node->binding)
1420 rhsLoc = node->binding->firstSourceLocation();
1421 else if (node->statement)
1422 rhsLoc = node->statement->firstSourceLocation();
1423 else
1424 rhsLoc = node->semicolonToken;
1425 alias->referenceLocation.set(line: rhsLoc.startLine, column: rhsLoc.startColumn);
1426
1427 QStringList aliasReference;
1428
1429 if (QQmlJS::AST::ExpressionStatement *stmt = QQmlJS::AST::cast<QQmlJS::AST::ExpressionStatement*>(ast: node->statement)) {
1430 aliasReference = astNodeToStringList(node: stmt->expression);
1431 if (aliasReference.isEmpty()) {
1432 if (isStatementNodeScript(statement: node->statement)) {
1433 COMPILE_EXCEPTION(rhsLoc, tr("Invalid alias reference. An alias reference must be specified as <id>, <id>.<property> or <id>.<value property>.<property>"));
1434 } else {
1435 COMPILE_EXCEPTION(rhsLoc, tr("Invalid alias location"));
1436 }
1437 }
1438 } else {
1439 COMPILE_EXCEPTION(rhsLoc, tr("Invalid alias reference. An alias reference must be specified as <id>, <id>.<property> or <id>.<value property>.<property>"));
1440 }
1441
1442 if (aliasReference.size() < 1 || aliasReference.size() > 3)
1443 COMPILE_EXCEPTION(rhsLoc, tr("Invalid alias reference. An alias reference must be specified as <id>, <id>.<property> or <id>.<value property>.<property>"));
1444
1445 alias->setIdIndex(registerString(str: aliasReference.first()));
1446
1447 QString propertyValue = aliasReference.value(i: 1);
1448 if (aliasReference.size() == 3)
1449 propertyValue += QLatin1Char('.') + aliasReference.at(i: 2);
1450 alias->propertyNameIndex = registerString(str: propertyValue);
1451
1452 QQmlJS::SourceLocation errorLocation;
1453 QString error;
1454
1455 if (illegalNames.contains(value: propName))
1456 error = tr(sourceText: "Illegal property name");
1457 else
1458 error = _object->appendAlias(alias, aliasName: propName, isDefaultProperty: node->isDefaultMember(), defaultToken: node->defaultToken(), errorLocation: &errorLocation);
1459
1460 if (!error.isEmpty()) {
1461 if (errorLocation.startLine == 0)
1462 errorLocation = node->identifierToken;
1463
1464 recordError(location: errorLocation, description: error);
1465 return false;
1466 }
1467
1468 return false;
1469}
1470
1471Object *IRBuilder::bindingsTarget() const
1472{
1473 if (_propertyDeclaration && _object->declarationsOverride)
1474 return _object->declarationsOverride;
1475 return _object;
1476}
1477
1478bool IRBuilder::setId(const QQmlJS::SourceLocation &idLocation, QQmlJS::AST::Statement *value)
1479{
1480 QQmlJS::SourceLocation loc = value->firstSourceLocation();
1481 QStringView str;
1482
1483 QQmlJS::AST::Node *node = value;
1484 if (QQmlJS::AST::ExpressionStatement *stmt = QQmlJS::AST::cast<QQmlJS::AST::ExpressionStatement *>(ast: node)) {
1485 if (QQmlJS::AST::StringLiteral *lit = QQmlJS::AST::cast<QQmlJS::AST::StringLiteral *>(ast: stmt->expression)) {
1486 str = lit->value;
1487 node = nullptr;
1488 } else
1489 node = stmt->expression;
1490 }
1491
1492 if (node && str.isEmpty())
1493 str = asStringRef(node);
1494
1495 if (str.isEmpty())
1496 COMPILE_EXCEPTION(loc, tr( "Invalid empty ID"));
1497
1498 QChar ch = str.at(n: 0);
1499 if (ch.isLetter() && !ch.isLower())
1500 COMPILE_EXCEPTION(loc, tr( "IDs cannot start with an uppercase letter"));
1501
1502 QChar u(QLatin1Char('_'));
1503 if (!ch.isLetter() && ch != u)
1504 COMPILE_EXCEPTION(loc, tr( "IDs must start with a letter or underscore"));
1505
1506 for (int ii = 1; ii < str.size(); ++ii) {
1507 ch = str.at(n: ii);
1508 if (!ch.isLetterOrNumber() && ch != u)
1509 COMPILE_EXCEPTION(loc, tr( "IDs must contain only letters, numbers, and underscores"));
1510 }
1511
1512 QString idQString(str.toString());
1513 if (illegalNames.contains(value: idQString))
1514 COMPILE_EXCEPTION(loc, tr( "ID illegally masks global JavaScript property"));
1515
1516 if (_object->idNameIndex != emptyStringIndex)
1517 COMPILE_EXCEPTION(idLocation, tr("Property value set multiple times"));
1518
1519 _object->idNameIndex = registerString(str: idQString);
1520 _object->locationOfIdProperty.set(line: idLocation.startLine, column: idLocation.startColumn);
1521
1522 return true;
1523}
1524
1525bool IRBuilder::resolveQualifiedId(QQmlJS::AST::UiQualifiedId **nameToResolve, Object **object, bool onAssignment)
1526{
1527 QQmlJS::AST::UiQualifiedId *qualifiedIdElement = *nameToResolve;
1528
1529 if (qualifiedIdElement->name == QLatin1String("id") && qualifiedIdElement->next)
1530 COMPILE_EXCEPTION(qualifiedIdElement->identifierToken, tr( "Invalid use of id property"));
1531
1532 // If it's a namespace, prepend the qualifier and we'll resolve it later to the correct type.
1533 QString currentName = qualifiedIdElement->name.toString();
1534 if (qualifiedIdElement->next) {
1535 for (const QV4::CompiledData::Import* import : std::as_const(t&: _imports))
1536 if (import->qualifierIndex != emptyStringIndex
1537 && stringAt(index: import->qualifierIndex) == currentName) {
1538 qualifiedIdElement = qualifiedIdElement->next;
1539 currentName += QLatin1Char('.') + qualifiedIdElement->name;
1540
1541 if (!qualifiedIdElement->name.data()->isUpper())
1542 COMPILE_EXCEPTION(qualifiedIdElement->firstSourceLocation(), tr("Expected type name"));
1543
1544 break;
1545 }
1546 }
1547
1548 *object = _object;
1549 while (qualifiedIdElement->next) {
1550 const quint32 propertyNameIndex = registerString(str: currentName);
1551 const bool isAttachedProperty = qualifiedIdElement->name.data()->isUpper();
1552
1553 Binding *binding = (*object)->findBinding(nameIndex: propertyNameIndex);
1554 if (binding) {
1555 if (isAttachedProperty) {
1556 if (!binding->isAttachedProperty())
1557 binding = nullptr;
1558 } else if (!binding->isGroupProperty()) {
1559 binding = nullptr;
1560 }
1561 }
1562 if (!binding) {
1563 binding = New<Binding>();
1564 binding->propertyNameIndex = propertyNameIndex;
1565 binding->offset = qualifiedIdElement->identifierToken.offset;
1566 binding->location.set(line: qualifiedIdElement->identifierToken.startLine,
1567 column: qualifiedIdElement->identifierToken.startColumn);
1568 binding->valueLocation.set(line: qualifiedIdElement->next->identifierToken.startLine,
1569 column: qualifiedIdElement->next->identifierToken.startColumn);
1570 binding->clearFlags();
1571
1572 if (onAssignment)
1573 binding->setFlag(QV4::CompiledData::Binding::IsOnAssignment);
1574
1575 if (isAttachedProperty)
1576 binding->setType(QV4::CompiledData::Binding::Type_AttachedProperty);
1577 else
1578 binding->setType(QV4::CompiledData::Binding::Type_GroupProperty);
1579
1580 int objIndex = 0;
1581 if (!defineQMLObject(objectIndex: &objIndex, qualifiedTypeNameId: nullptr, location: binding->location, initializer: nullptr, declarationsOverride: nullptr))
1582 return false;
1583 binding->value.objectIndex = objIndex;
1584
1585 QString error = (*object)->appendBinding(b: binding, /*isListBinding*/false);
1586 if (!error.isEmpty()) {
1587 recordError(location: qualifiedIdElement->identifierToken, description: error);
1588 return false;
1589 }
1590 *object = _objects.at(i: objIndex);
1591 } else {
1592 Q_ASSERT(binding->isAttachedProperty() || binding->isGroupProperty());
1593 *object = _objects.at(i: binding->value.objectIndex);
1594 }
1595
1596 qualifiedIdElement = qualifiedIdElement->next;
1597 if (qualifiedIdElement)
1598 currentName = qualifiedIdElement->name.toString();
1599 }
1600 *nameToResolve = qualifiedIdElement;
1601 return true;
1602}
1603
1604void IRBuilder::recordError(const QQmlJS::SourceLocation &location, const QString &description)
1605{
1606 QQmlJS::DiagnosticMessage error;
1607 error.loc = location;
1608 error.message = description;
1609 errors << error;
1610}
1611
1612bool IRBuilder::isStatementNodeScript(QQmlJS::AST::Statement *statement)
1613{
1614 if (QQmlJS::AST::ExpressionStatement *stmt = QQmlJS::AST::cast<QQmlJS::AST::ExpressionStatement *>(ast: statement)) {
1615 QQmlJS::AST::ExpressionNode *expr = stmt->expression;
1616 if (QQmlJS::AST::cast<QQmlJS::AST::StringLiteral *>(ast: expr))
1617 return false;
1618 else if (expr->kind == QQmlJS::AST::Node::Kind_TrueLiteral)
1619 return false;
1620 else if (expr->kind == QQmlJS::AST::Node::Kind_FalseLiteral)
1621 return false;
1622 else if (QQmlJS::AST::cast<QQmlJS::AST::NumericLiteral *>(ast: expr))
1623 return false;
1624 else {
1625
1626 if (QQmlJS::AST::UnaryMinusExpression *unaryMinus = QQmlJS::AST::cast<QQmlJS::AST::UnaryMinusExpression *>(ast: expr)) {
1627 if (QQmlJS::AST::cast<QQmlJS::AST::NumericLiteral *>(ast: unaryMinus->expression)) {
1628 return false;
1629 }
1630 }
1631 }
1632 }
1633
1634 return true;
1635}
1636
1637bool IRBuilder::isRedundantNullInitializerForPropertyDeclaration(Property *property, QQmlJS::AST::Statement *statement)
1638{
1639 if (property->isCommonType() || property->isList())
1640 return false;
1641 QQmlJS::AST::ExpressionStatement *exprStmt = QQmlJS::AST::cast<QQmlJS::AST::ExpressionStatement *>(ast: statement);
1642 if (!exprStmt)
1643 return false;
1644 QQmlJS::AST::ExpressionNode * const expr = exprStmt->expression;
1645 return QQmlJS::AST::cast<QQmlJS::AST::NullExpression *>(ast: expr);
1646}
1647
1648void QmlUnitGenerator::generate(Document &output, const QV4::CompiledData::DependentTypesHasher &dependencyHasher)
1649{
1650 using namespace QV4::CompiledData;
1651
1652 output.jsGenerator.stringTable.registerString(str: output.jsModule.fileName);
1653 output.jsGenerator.stringTable.registerString(str: output.jsModule.finalUrl);
1654
1655 Unit *jsUnit = nullptr;
1656
1657 if (!output.javaScriptCompilationUnit)
1658 output.javaScriptCompilationUnit.adopt(other: new QV4::CompiledData::CompilationUnit);
1659
1660 // We may already have unit data if we're loading an ahead-of-time generated cache file.
1661 if (output.javaScriptCompilationUnit->unitData()) {
1662 jsUnit = const_cast<Unit *>(output.javaScriptCompilationUnit->unitData());
1663 output.javaScriptCompilationUnit->dynamicStrings
1664 = output.jsGenerator.stringTable.allStrings();
1665 } else {
1666 Unit *createdUnit;
1667 jsUnit = createdUnit = output.jsGenerator.generateUnit();
1668
1669 // enable flag if we encountered pragma Singleton
1670 for (Pragma *p : std::as_const(t&: output.pragmas)) {
1671 switch (p->type) {
1672 case Pragma::Singleton:
1673 createdUnit->flags |= Unit::IsSingleton;
1674 break;
1675 case Pragma::Strict:
1676 createdUnit->flags |= Unit::IsStrict;
1677 break;
1678 case Pragma::ComponentBehavior:
1679 // ### Qt7: Change the default to Bound by reverting the meaning of the flag.
1680 switch (p->componentBehavior) {
1681 case Pragma::Bound:
1682 createdUnit->flags |= Unit::ComponentsBound;
1683 break;
1684 case Pragma::Unbound:
1685 // this is the default
1686 break;
1687 }
1688 break;
1689 case Pragma::ListPropertyAssignBehavior:
1690 switch (p->listPropertyAssignBehavior) {
1691 case Pragma::Replace:
1692 createdUnit->flags |= Unit::ListPropertyAssignReplace;
1693 break;
1694 case Pragma::ReplaceIfNotDefault:
1695 createdUnit->flags |= Unit::ListPropertyAssignReplaceIfNotDefault;
1696 break;
1697 case Pragma::Append:
1698 // this is the default
1699 break;
1700 }
1701 break;
1702 case Pragma::FunctionSignatureBehavior:
1703 switch (p->functionSignatureBehavior) {
1704 case Pragma::Enforced:
1705 break;
1706 case Pragma::Ignored:
1707 createdUnit->flags |= Unit::FunctionSignaturesIgnored;
1708 break;
1709 }
1710 break;
1711 case Pragma::NativeMethodBehavior:
1712 switch (p->nativeMethodBehavior) {
1713 case Pragma::AcceptThisObject:
1714 createdUnit->flags |= Unit::NativeMethodsAcceptThisObject;
1715 break;
1716 case Pragma::RejectThisObject:
1717 // this is the default;
1718 break;
1719 }
1720 break;
1721 case Pragma::ValueTypeBehavior:
1722 if (Pragma::ValueTypeBehaviorValues(p->valueTypeBehavior)
1723 .testFlag(flag: Pragma::Copy)) {
1724 createdUnit->flags |= Unit::ValueTypesCopied;
1725 }
1726 if (Pragma::ValueTypeBehaviorValues(p->valueTypeBehavior)
1727 .testFlag(flag: Pragma::Addressable)) {
1728 createdUnit->flags |= Unit::ValueTypesAddressable;
1729 }
1730 if (Pragma::ValueTypeBehaviorValues(p->valueTypeBehavior)
1731 .testFlag(flag: Pragma::Assertable)) {
1732 createdUnit->flags |= Unit::ValueTypesAssertable;
1733 }
1734 break;
1735 case Pragma::Translator:
1736 if (createdUnit->translationTableSize)
1737 if (quint32_le *index = createdUnit->translationContextIndex())
1738 *index = p->translationContextIndex;
1739 break;
1740 }
1741 }
1742
1743 if (dependencyHasher) {
1744 const QByteArray checksum = dependencyHasher();
1745 if (checksum.size() == sizeof(createdUnit->dependencyMD5Checksum)) {
1746 memcpy(dest: createdUnit->dependencyMD5Checksum, src: checksum.constData(),
1747 n: sizeof(createdUnit->dependencyMD5Checksum));
1748 }
1749 }
1750
1751 createdUnit->sourceFileIndex = output.jsGenerator.stringTable.getStringId(string: output.jsModule.fileName);
1752 createdUnit->finalUrlIndex = output.jsGenerator.stringTable.getStringId(string: output.jsModule.finalUrl);
1753 }
1754
1755 // No more new strings after this point, we're calculating offsets.
1756 output.jsGenerator.stringTable.freeze();
1757
1758 const uint importSize = uint(sizeof(QV4::CompiledData::Import)) * output.imports.size();
1759 const uint objectOffsetTableSize = output.objects.size() * uint(sizeof(quint32));
1760
1761 QHash<const Object*, quint32> objectOffsets;
1762
1763 const unsigned int objectOffset = sizeof(QV4::CompiledData::QmlUnit) + importSize;
1764 uint nextOffset = objectOffset + objectOffsetTableSize;
1765 for (Object *o : std::as_const(t&: output.objects)) {
1766 objectOffsets.insert(key: o, value: nextOffset);
1767 nextOffset += QV4::CompiledData::Object::calculateSizeExcludingSignalsAndEnums(nFunctions: o->functionCount(), nProperties: o->propertyCount(), nAliases: o->aliasCount(), nEnums: o->enumCount(), nSignals: o->signalCount(), nBindings: o->bindingCount(), nNamedObjectsInComponent: o->namedObjectsInComponent.size(), nInlineComponents: o->inlineComponentCount(), nRequiredPropertyExtraData: o->requiredPropertyExtraDataCount());
1768
1769 int signalTableSize = 0;
1770 for (const Signal *s = o->firstSignal(); s; s = s->next)
1771 signalTableSize += QV4::CompiledData::Signal::calculateSize(nParameters: s->parameters->count);
1772
1773 nextOffset += signalTableSize;
1774
1775 int enumTableSize = 0;
1776 for (const Enum *e = o->firstEnum(); e; e = e->next)
1777 enumTableSize += QV4::CompiledData::Enum::calculateSize(nEnumValues: e->enumValues->count);
1778
1779 nextOffset += enumTableSize;
1780 }
1781
1782 const uint totalSize = nextOffset;
1783 char *data = (char*)malloc(size: totalSize);
1784 memset(s: data, c: 0, n: totalSize);
1785 QV4::CompiledData::QmlUnit *qmlUnit = reinterpret_cast<QV4::CompiledData::QmlUnit *>(data);
1786 qmlUnit->offsetToImports = sizeof(*qmlUnit);
1787 qmlUnit->nImports = output.imports.size();
1788 qmlUnit->offsetToObjects = objectOffset;
1789 qmlUnit->nObjects = output.objects.size();
1790
1791 // write imports
1792 char *importPtr = data + qmlUnit->offsetToImports;
1793 for (const QV4::CompiledData::Import *imp : std::as_const(t&: output.imports)) {
1794 QV4::CompiledData::Import *importToWrite = reinterpret_cast<QV4::CompiledData::Import*>(importPtr);
1795 *importToWrite = *imp;
1796 importPtr += sizeof(QV4::CompiledData::Import);
1797 }
1798
1799 // write objects
1800 quint32_le *objectTable = reinterpret_cast<quint32_le*>(data + qmlUnit->offsetToObjects);
1801 for (int i = 0; i < output.objects.size(); ++i) {
1802 const Object *o = output.objects.at(i);
1803 char * const objectPtr = data + objectOffsets.value(key: o);
1804 *objectTable++ = objectOffsets.value(key: o);
1805
1806 QV4::CompiledData::Object *objectToWrite = reinterpret_cast<QV4::CompiledData::Object*>(objectPtr);
1807 objectToWrite->inheritedTypeNameIndex = o->inheritedTypeNameIndex;
1808 objectToWrite->indexOfDefaultPropertyOrAlias = o->indexOfDefaultPropertyOrAlias;
1809 objectToWrite->setHasAliasAsDefaultProperty(o->defaultPropertyIsAlias);
1810 objectToWrite->setFlags(QV4::CompiledData::Object::Flags(o->flags));
1811 objectToWrite->idNameIndex = o->idNameIndex;
1812 objectToWrite->setObjectId(o->id);
1813 objectToWrite->location = o->location;
1814 objectToWrite->locationOfIdProperty = o->locationOfIdProperty;
1815
1816 quint32 nextOffset = sizeof(QV4::CompiledData::Object);
1817
1818 objectToWrite->nFunctions = o->functionCount();
1819 objectToWrite->offsetToFunctions = nextOffset;
1820 nextOffset += objectToWrite->nFunctions * sizeof(quint32);
1821
1822 objectToWrite->nProperties = o->propertyCount();
1823 objectToWrite->offsetToProperties = nextOffset;
1824 nextOffset += objectToWrite->nProperties * sizeof(QV4::CompiledData::Property);
1825
1826 objectToWrite->nAliases = o->aliasCount();
1827 objectToWrite->offsetToAliases = nextOffset;
1828 nextOffset += objectToWrite->nAliases * sizeof(QV4::CompiledData::Alias);
1829
1830 objectToWrite->nEnums = o->enumCount();
1831 objectToWrite->offsetToEnums = nextOffset;
1832 nextOffset += objectToWrite->nEnums * sizeof(quint32);
1833
1834 objectToWrite->nSignals = o->signalCount();
1835 objectToWrite->offsetToSignals = nextOffset;
1836 nextOffset += objectToWrite->nSignals * sizeof(quint32);
1837
1838 objectToWrite->nBindings = o->bindingCount();
1839 objectToWrite->offsetToBindings = nextOffset;
1840 nextOffset += objectToWrite->nBindings * sizeof(QV4::CompiledData::Binding);
1841
1842 objectToWrite->nNamedObjectsInComponent = o->namedObjectsInComponent.size();
1843 objectToWrite->offsetToNamedObjectsInComponent = nextOffset;
1844 nextOffset += objectToWrite->nNamedObjectsInComponent * sizeof(quint32);
1845
1846 objectToWrite->nInlineComponents = o->inlineComponentCount();
1847 objectToWrite->offsetToInlineComponents = nextOffset;
1848 nextOffset += objectToWrite->nInlineComponents * sizeof (QV4::CompiledData::InlineComponent);
1849
1850 objectToWrite->nRequiredPropertyExtraData = o->requiredPropertyExtraDataCount();
1851 objectToWrite->offsetToRequiredPropertyExtraData = nextOffset;
1852 nextOffset += objectToWrite->nRequiredPropertyExtraData * sizeof(QV4::CompiledData::RequiredPropertyExtraData);
1853
1854 quint32_le *functionsTable = reinterpret_cast<quint32_le *>(objectPtr + objectToWrite->offsetToFunctions);
1855 for (const Function *f = o->firstFunction(); f; f = f->next)
1856 *functionsTable++ = o->runtimeFunctionIndices.at(index: f->index);
1857
1858 char *propertiesPtr = objectPtr + objectToWrite->offsetToProperties;
1859 for (const Property *p = o->firstProperty(); p; p = p->next) {
1860 QV4::CompiledData::Property *propertyToWrite = reinterpret_cast<QV4::CompiledData::Property*>(propertiesPtr);
1861 *propertyToWrite = *p;
1862 propertiesPtr += sizeof(QV4::CompiledData::Property);
1863 }
1864
1865 char *aliasesPtr = objectPtr + objectToWrite->offsetToAliases;
1866 for (const Alias *a = o->firstAlias(); a; a = a->next) {
1867 QV4::CompiledData::Alias *aliasToWrite = reinterpret_cast<QV4::CompiledData::Alias*>(aliasesPtr);
1868 *aliasToWrite = *a;
1869 aliasesPtr += sizeof(QV4::CompiledData::Alias);
1870 }
1871
1872 char *bindingPtr = objectPtr + objectToWrite->offsetToBindings;
1873 bindingPtr = writeBindings(bindingPtr, o, filter: &QV4::CompiledData::Binding::isValueBindingNoAlias);
1874 bindingPtr = writeBindings(bindingPtr, o, filter: &QV4::CompiledData::Binding::isSignalHandler);
1875 bindingPtr = writeBindings(bindingPtr, o, filter: &QV4::CompiledData::Binding::isAttachedProperty);
1876 bindingPtr = writeBindings(bindingPtr, o, filter: &QV4::CompiledData::Binding::isGroupProperty);
1877 bindingPtr = writeBindings(bindingPtr, o, filter: &QV4::CompiledData::Binding::isValueBindingToAlias);
1878 Q_ASSERT((bindingPtr - objectToWrite->offsetToBindings - objectPtr) / sizeof(QV4::CompiledData::Binding) == unsigned(o->bindingCount()));
1879
1880 quint32_le *signalOffsetTable = reinterpret_cast<quint32_le *>(objectPtr + objectToWrite->offsetToSignals);
1881 quint32 signalTableSize = 0;
1882 char *signalPtr = objectPtr + nextOffset;
1883 for (const Signal *s = o->firstSignal(); s; s = s->next) {
1884 *signalOffsetTable++ = signalPtr - objectPtr;
1885 QV4::CompiledData::Signal *signalToWrite = reinterpret_cast<QV4::CompiledData::Signal*>(signalPtr);
1886
1887 signalToWrite->nameIndex = s->nameIndex;
1888 signalToWrite->location = s->location;
1889 signalToWrite->nParameters = s->parameters->count;
1890
1891 QV4::CompiledData::Parameter *parameterToWrite = reinterpret_cast<QV4::CompiledData::Parameter*>(signalPtr + sizeof(*signalToWrite));
1892 for (Parameter *param = s->parameters->first; param; param = param->next, ++parameterToWrite)
1893 *parameterToWrite = *param;
1894
1895 int size = QV4::CompiledData::Signal::calculateSize(nParameters: s->parameters->count);
1896 signalTableSize += size;
1897 signalPtr += size;
1898 }
1899 nextOffset += signalTableSize;
1900
1901 quint32_le *enumOffsetTable = reinterpret_cast<quint32_le*>(objectPtr + objectToWrite->offsetToEnums);
1902 char *enumPtr = objectPtr + nextOffset;
1903 for (const Enum *e = o->firstEnum(); e; e = e->next) {
1904 *enumOffsetTable++ = enumPtr - objectPtr;
1905 QV4::CompiledData::Enum *enumToWrite = reinterpret_cast<QV4::CompiledData::Enum*>(enumPtr);
1906
1907 enumToWrite->nameIndex = e->nameIndex;
1908 enumToWrite->location = e->location;
1909 enumToWrite->nEnumValues = e->enumValues->count;
1910
1911 QV4::CompiledData::EnumValue *enumValueToWrite = reinterpret_cast<QV4::CompiledData::EnumValue*>(enumPtr + sizeof(*enumToWrite));
1912 for (EnumValue *enumValue = e->enumValues->first; enumValue; enumValue = enumValue->next, ++enumValueToWrite)
1913 *enumValueToWrite = *enumValue;
1914
1915 int size = QV4::CompiledData::Enum::calculateSize(nEnumValues: e->enumValues->count);
1916 enumPtr += size;
1917 }
1918
1919 quint32_le *namedObjectInComponentPtr = reinterpret_cast<quint32_le *>(objectPtr + objectToWrite->offsetToNamedObjectsInComponent);
1920 for (int i = 0; i < o->namedObjectsInComponent.size(); ++i) {
1921 *namedObjectInComponentPtr++ = o->namedObjectsInComponent.at(index: i);
1922 }
1923
1924 char *inlineComponentPtr = objectPtr + objectToWrite->offsetToInlineComponents;
1925 for (auto it = o->inlineComponentsBegin(); it != o->inlineComponentsEnd(); ++it) {
1926 const InlineComponent *ic = it.ptr;
1927 QV4::CompiledData::InlineComponent *icToWrite = reinterpret_cast<QV4::CompiledData::InlineComponent*>(inlineComponentPtr);
1928 *icToWrite = *ic;
1929 inlineComponentPtr += sizeof(QV4::CompiledData::InlineComponent);
1930 }
1931
1932 char *requiredPropertyExtraDataPtr = objectPtr + objectToWrite->offsetToRequiredPropertyExtraData;
1933 for (auto it = o->requiredPropertyExtraDataBegin(); it != o->requiredPropertyExtraDataEnd(); ++it) {
1934 const RequiredPropertyExtraData *extraData = it.ptr;
1935 QV4::CompiledData::RequiredPropertyExtraData *extraDataToWrite = reinterpret_cast<QV4::CompiledData::RequiredPropertyExtraData*>(requiredPropertyExtraDataPtr);
1936 *extraDataToWrite = *extraData;
1937 requiredPropertyExtraDataPtr += sizeof(QV4::CompiledData::RequiredPropertyExtraData);
1938 }
1939 }
1940
1941 if (!output.javaScriptCompilationUnit->unitData()) {
1942 // Combine the qml data into the general unit data.
1943 jsUnit = static_cast<QV4::CompiledData::Unit *>(realloc(ptr: jsUnit, size: jsUnit->unitSize + totalSize));
1944 jsUnit->offsetToQmlUnit = jsUnit->unitSize;
1945 jsUnit->unitSize += totalSize;
1946 memcpy(dest: jsUnit->qmlUnit(), src: qmlUnit, n: totalSize);
1947 free(ptr: qmlUnit);
1948 QV4::Compiler::JSUnitGenerator::generateUnitChecksum(unit: jsUnit);
1949 qmlUnit = jsUnit->qmlUnit();
1950 }
1951
1952 static const bool showStats = qEnvironmentVariableIsSet(varName: "QML_SHOW_UNIT_STATS");
1953 if (showStats) {
1954 qDebug() << "Generated QML unit that is" << totalSize << "bytes big contains:";
1955 qDebug() << " " << jsUnit->functionTableSize << "functions";
1956 qDebug() << " " << jsUnit->unitSize << "for JS unit";
1957 qDebug() << " " << importSize << "for imports";
1958 qDebug() << " " << nextOffset - objectOffset - objectOffsetTableSize << "for" << qmlUnit->nObjects << "objects";
1959 quint32 totalBindingCount = 0;
1960 for (quint32 i = 0; i < qmlUnit->nObjects; ++i)
1961 totalBindingCount += qmlUnit->objectAt(idx: i)->nBindings;
1962 qDebug() << " " << totalBindingCount << "bindings";
1963 quint32 totalCodeSize = 0;
1964 for (quint32 i = 0; i < jsUnit->functionTableSize; ++i)
1965 totalCodeSize += jsUnit->functionAt(idx: i)->codeSize;
1966 qDebug() << " " << totalCodeSize << "bytes total byte code";
1967 qDebug() << " " << jsUnit->stringTableSize << "strings";
1968 quint32 totalStringSize = 0;
1969 for (quint32 i = 0; i < jsUnit->stringTableSize; ++i)
1970 totalStringSize += QV4::CompiledData::String::calculateSize(str: jsUnit->stringAtInternal(idx: i));
1971 qDebug() << " " << totalStringSize << "bytes total strings";
1972 }
1973
1974 output.javaScriptCompilationUnit->setUnitData(
1975 unitData: jsUnit, qmlUnit, fileName: output.jsModule.fileName, finalUrlString: output.jsModule.finalUrl);
1976}
1977
1978char *QmlUnitGenerator::writeBindings(char *bindingPtr, const Object *o, BindingFilter filter) const
1979{
1980 for (const Binding *b = o->firstBinding(); b; b = b->next) {
1981 if (!(b->*(filter))())
1982 continue;
1983 QV4::CompiledData::Binding *bindingToWrite = reinterpret_cast<QV4::CompiledData::Binding*>(bindingPtr);
1984 *bindingToWrite = *b;
1985 if (b->type() == QV4::CompiledData::Binding::Type_Script)
1986 bindingToWrite->value.compiledScriptIndex = o->runtimeFunctionIndices.at(index: b->value.compiledScriptIndex);
1987 bindingPtr += sizeof(QV4::CompiledData::Binding);
1988 }
1989 return bindingPtr;
1990}
1991
1992JSCodeGen::JSCodeGen(Document *document, const QSet<QString> &globalNames,
1993 QV4::Compiler::CodegenWarningInterface *iface,
1994 bool storeSourceLocations)
1995 : QV4::Compiler::Codegen(&document->jsGenerator, /*strict mode*/ false, iface,
1996 storeSourceLocations),
1997 document(document)
1998{
1999 m_globalNames = globalNames;
2000 _module = &document->jsModule;
2001 _fileNameIsUrl = true;
2002}
2003
2004QVector<int> JSCodeGen::generateJSCodeForFunctionsAndBindings(
2005 const QList<CompiledFunctionOrExpression> &functions)
2006{
2007 auto qmlName = [&](const CompiledFunctionOrExpression &c) {
2008 if (c.nameIndex != 0)
2009 return document->stringAt(index: c.nameIndex);
2010 else
2011 return QStringLiteral("%qml-expression-entry");
2012 };
2013 QVector<int> runtimeFunctionIndices(functions.size());
2014
2015 QV4::Compiler::ScanFunctions scan(this, document->code, QV4::Compiler::ContextType::Global);
2016 scan.enterGlobalEnvironment(compilationMode: QV4::Compiler::ContextType::Binding);
2017 for (const CompiledFunctionOrExpression &f : functions) {
2018 Q_ASSERT(f.node != document->program);
2019 Q_ASSERT(f.parentNode && f.parentNode != document->program);
2020 auto function = f.node->asFunctionDefinition();
2021
2022 if (function) {
2023 scan.enterQmlFunction(ast: function);
2024 } else {
2025 Q_ASSERT(f.node != f.parentNode);
2026 scan.enterEnvironment(node: f.parentNode, compilationMode: QV4::Compiler::ContextType::Binding, name: qmlName(f));
2027 }
2028
2029 /* We do not want to visit the whole function, as we already called enterQmlFunction
2030 However, there might be a function defined as a default argument of the function.
2031 That needs to be considered, too, so we call handleTopLevelFunctionFormals to
2032 deal with them.
2033 */
2034 scan.handleTopLevelFunctionFormals(node: function);
2035 scan(function ? function->body : f.node);
2036 scan.leaveEnvironment();
2037 }
2038 scan.leaveEnvironment();
2039
2040 if (hasError())
2041 return QVector<int>();
2042
2043 _context = nullptr;
2044
2045 for (int i = 0; i < functions.size(); ++i) {
2046 const CompiledFunctionOrExpression &qmlFunction = functions.at(i);
2047 QQmlJS::AST::Node *node = qmlFunction.node;
2048 Q_ASSERT(node != document->program);
2049
2050 QQmlJS::AST::FunctionExpression *function = node->asFunctionDefinition();
2051
2052 QString name;
2053 if (function)
2054 name = function->name.toString();
2055 else
2056 name = qmlName(qmlFunction);
2057
2058 QQmlJS::AST::StatementList *body;
2059 if (function) {
2060 body = function->body;
2061 } else {
2062 // Synthesize source elements.
2063 QQmlJS::MemoryPool *pool = document->jsParserEngine.pool();
2064
2065 QQmlJS::AST::Statement *stmt = node->statementCast();
2066 if (!stmt) {
2067 Q_ASSERT(node->expressionCast());
2068 QQmlJS::AST::ExpressionNode *expr = node->expressionCast();
2069 stmt = new (pool) QQmlJS::AST::ExpressionStatement(expr);
2070 }
2071 body = new (pool) QQmlJS::AST::StatementList(stmt);
2072 body = body->finish();
2073 }
2074
2075 int idx = defineFunction(name, ast: function ? function : qmlFunction.parentNode,
2076 formals: function ? function->formals : nullptr, body);
2077 runtimeFunctionIndices[i] = idx;
2078 }
2079
2080 return runtimeFunctionIndices;
2081}
2082
2083bool JSCodeGen::generateRuntimeFunctions(QmlIR::Object *object)
2084{
2085 if (object->functionsAndExpressions->count == 0)
2086 return true;
2087
2088 QList<QmlIR::CompiledFunctionOrExpression> functionsToCompile;
2089 functionsToCompile.reserve(asize: object->functionsAndExpressions->count);
2090 for (QmlIR::CompiledFunctionOrExpression *foe = object->functionsAndExpressions->first; foe;
2091 foe = foe->next) {
2092 functionsToCompile << *foe;
2093 }
2094
2095 const auto runtimeFunctionIndices = generateJSCodeForFunctionsAndBindings(functions: functionsToCompile);
2096 if (hasError())
2097 return false;
2098
2099 object->runtimeFunctionIndices.allocate(pool: document->jsParserEngine.pool(),
2100 vector: runtimeFunctionIndices);
2101 return true;
2102}
2103

Provided by KDAB

Privacy Policy
Learn Advanced QML with KDAB
Find out more

source code of qtdeclarative/src/qml/compiler/qqmlirbuilder.cpp