FCL/sf/mw/qt: comparison src/declarative/qml/qdeclarativecompiler.cpp

equal deleted inserted replaced

-:ef0373b55136
+:758a864f9613
 **
 ****************************************************************************/
 #include "private/qdeclarativecompiler_p.h"
-#include "private/qdeclarativecompositetypedata_p.h"
 #include "private/qdeclarativeparser_p.h"
 #include "private/qdeclarativescriptparser_p.h"
 #include "qdeclarativepropertyvaluesource.h"
 #include "qdeclarativecomponent.h"
 #include "private/qmetaobjectbuilder_p.h"
 bool ok;
 QDeclarativeStringConverters::colorFromString(string, &ok);
 if (!ok) COMPILE_EXCEPTION(v, tr("Invalid property assignment: color expected"));
 }
 break;
-#ifndef QT_NO_TEXTDATE
+#ifndef QT_NO_DATESTRING
 case QVariant::Date:
 {
 bool ok;
 QDeclarativeStringConverters::dateFromString(string, &ok);
 if (!ok) COMPILE_EXCEPTION(v, tr("Invalid property assignment: date expected"));
 bool ok;
 QDeclarativeStringConverters::dateTimeFromString(string, &ok);
 if (!ok) COMPILE_EXCEPTION(v, tr("Invalid property assignment: datetime expected"));
 }
 break;
-#endif // QT_NO_TEXTDATE
+#endif // QT_NO_DATESTRING
 case QVariant::Point:
 case QVariant::PointF:
 {
 bool ok;
 QPointF point = QDeclarativeStringConverters::pointFFromString(string, &ok);
 instr.type = QDeclarativeInstruction::StoreColor;
 instr.storeColor.propertyIndex = prop.propertyIndex();
 instr.storeColor.value = c.rgba();
 }
 break;
-#ifndef QT_NO_TEXTDATE
+#ifndef QT_NO_DATESTRING
 case QVariant::Date:
 {
 QDate d = QDeclarativeStringConverters::dateFromString(string);
 instr.type = QDeclarativeInstruction::StoreDate;
 instr.storeDate.propertyIndex = prop.propertyIndex();
 instr.type = QDeclarativeInstruction::StoreDateTime;
 instr.storeDateTime.propertyIndex = prop.propertyIndex();
 instr.storeDateTime.valueIndex = index;
 }
 break;
-#endif // QT_NO_TEXTDATE
+#endif // QT_NO_DATESTRING
 case QVariant::Point:
 case QVariant::PointF:
 {
 bool ok;
 QPointF point =
 If the environment variant QML_COMPILER_DUMP is set
 (eg. QML_COMPILER_DUMP=1) the compiled instructions will be dumped to stderr
 on a successful compiler.
 */
 bool QDeclarativeCompiler::compile(QDeclarativeEngine *engine,
-QDeclarativeCompositeTypeData *unit,
+QDeclarativeTypeData *unit,
 QDeclarativeCompiledData *out)
 {
 exceptions.clear();
 Q_ASSERT(out);
 reset(out);
 output = out;
 // Compile types
-for (int ii = 0; ii < unit->types.count(); ++ii) {
+const QList<QDeclarativeTypeData::TypeReference>  &resolvedTypes = unit->resolvedTypes();
-QDeclarativeCompositeTypeData::TypeReference &tref = unit->types[ii];
+QList<QDeclarativeScriptParser::TypeReference *> referencedTypes = unit->parser().referencedTypes();
+for (int ii = 0; ii < resolvedTypes.count(); ++ii) {
 QDeclarativeCompiledData::TypeReference ref;
-QDeclarativeScriptParser::TypeReference *parserRef = unit->data.referencedTypes().at(ii);
+const QDeclarativeTypeData::TypeReference &tref = resolvedTypes.at(ii);
+QDeclarativeScriptParser::TypeReference *parserRef = referencedTypes.at(ii);
 if (tref.type) {
 ref.type = tref.type;
 if (!ref.type->isCreatable()) {
 QString err = ref.type->noCreationReason();
 if (err.isEmpty())
 err = tr( "Element is not creatable.");
 COMPILE_EXCEPTION(parserRef->refObjects.first(), err);
 }
-} else if (tref.unit) {
+} else if (tref.typeData) {
-ref.component = tref.unit->toComponent(engine);
+ref.component = tref.typeData->component();
+ref.ref = tref.typeData;
-if (ref.component->isError()) {
-QDeclarativeError error;
-error.setUrl(output->url);
-error.setDescription(QLatin1String("Unable to create type ") +
-parserRef->name);
-if (!parserRef->refObjects.isEmpty()) {
-QDeclarativeParser::Object *parserObject = parserRef->refObjects.first();
-error.setLine(parserObject->location.start.line);
-error.setColumn(parserObject->location.start.column);
-}
-exceptions << error;
-exceptions << ref.component->errors();
-reset(out);
-return false;
-}
-ref.ref = tref.unit;
 ref.ref->addref();
 }
 ref.className = parserRef->name.toUtf8();
 out->types << ref;
 }
-Object *root = unit->data.tree();
+Object *root = unit->parser().tree();
 Q_ASSERT(root);
 this->engine = engine;
 this->enginePrivate = QDeclarativeEnginePrivate::get(engine);
 this->unit = unit;
 // Build global import scripts
 QHash<QString, Object::ScriptBlock> importedScripts;
 QStringList importedScriptIndexes;
-for (int ii = 0; ii < unit->scripts.count(); ++ii) {
+foreach (const QDeclarativeTypeData::ScriptReference &script, unit->resolvedScripts()) {
-QString scriptCode = QString::fromUtf8(unit->scripts.at(ii).resource->data);
+QString scriptCode = script.script->scriptSource();
-Object::ScriptBlock::Pragmas pragmas = QDeclarativeScriptParser::extractPragmas(scriptCode);
+Object::ScriptBlock::Pragmas pragmas = script.script->pragmas();
+Q_ASSERT(!importedScripts.contains(script.qualifier));
 if (!scriptCode.isEmpty()) {
-Object::ScriptBlock &scriptBlock = importedScripts[unit->scripts.at(ii).qualifier];
+Object::ScriptBlock &scriptBlock = importedScripts[script.qualifier];
-scriptBlock.codes.append(scriptCode);
+scriptBlock.code = scriptCode;
-scriptBlock.lineNumbers.append(1);
+scriptBlock.file = script.script->finalUrl().toString();
-scriptBlock.files.append(unit->scripts.at(ii).resource->url);
+scriptBlock.pragmas = pragmas;
-scriptBlock.pragmas.append(pragmas);
 }
 }
 for (QHash<QString, Object::ScriptBlock>::Iterator iter = importedScripts.begin();
 iter != importedScripts.end(); ++iter) {
 output->importCache = new QDeclarativeTypeNameCache(engine);
 for (int ii = 0; ii < importedScriptIndexes.count(); ++ii)
 output->importCache->add(importedScriptIndexes.at(ii), ii);
-unit->imports.cache(output->importCache, engine);
+unit->imports().populateCache(output->importCache, engine);
 Q_ASSERT(tree->metatype);
 if (tree->metadata.isEmpty()) {
 output->root = tree->metatype;
 id.setId.index = obj->idIndex;
 output->bytecode << id;
 }
 // Begin the class
-if (obj->parserStatusCast != -1) {
+if (tr.type && obj->parserStatusCast != -1) {
 QDeclarativeInstruction begin;
 begin.type = QDeclarativeInstruction::BeginObject;
 begin.begin.castValue = obj->parserStatusCast;
 begin.line = obj->location.start.line;
 output->bytecode << begin;
 store.line = v->location.start.line;
 store.storeSignal.signalIndex = prop->index;
 store.storeSignal.value =
 output->indexForString(v->value.asScript().trimmed());
 store.storeSignal.context = ctxt.stack;
+store.storeSignal.name = output->indexForByteArray(prop->name);
 output->bytecode << store;
 }
 }
 if (prop->isDefault) {
 QMetaProperty p = QDeclarativeMetaType::defaultProperty(mo);
 return p.name() != 0;
 } else {
 int idx = mo->indexOfProperty(prop->name.constData());
-return idx != -1;
+return idx != -1 && mo->property(idx).isScriptable();
 }
 }
 return false;
 }
 COMPILE_EXCEPTION(prop, tr("Attached properties cannot be used here"));
 }
 QDeclarativeType *type = 0;
 QDeclarativeImportedNamespace *typeNamespace = 0;
-enginePrivate->importDatabase.resolveType(unit->imports, prop->name,
+unit->imports().resolveType(prop->name, &type, 0, 0, 0, &typeNamespace);
-&type, 0, 0, 0, &typeNamespace);
 if (typeNamespace) {
 // ### We might need to indicate that this property is a namespace
 // for the DOM API
 COMPILE_CHECK(buildPropertyInNamespace(typeNamespace, prop, obj,
 prop->index = metaObject->indexOfProperty(prop->name.constData());
 if (prop->index != -1) {
 p = metaObject->property(prop->index);
 Q_ASSERT(p.name());
+if (!p.isScriptable()) {
+prop->index = -1;
+p = QMetaProperty();
+}
 }
 }
 // We can't error here as the "id" property does not require a
 // successful index resolution
 COMPILE_EXCEPTION(prop, tr("Not an attached property name"));
 // Setup attached property data
 QDeclarativeType *type = 0;
-enginePrivate->importDatabase.resolveTypeInNamespace(ns, prop->name, &type, 0, 0, 0);
+unit->imports().resolveType(ns, prop->name, &type, 0, 0, 0);
 if (!type || !type->attachedPropertiesType())
 COMPILE_EXCEPTION(prop, tr("Non-existent attached object"));
 if (!prop->value)
 {
 Q_ASSERT(prop->type != 0);
 Q_ASSERT(prop->index != -1);
 if (QDeclarativeValueTypeFactory::isValueType(prop->type)) {
-QDeclarativeEnginePrivate *ep =
+if (prop->type >= 0 /* QVariant == -1 */ && enginePrivate->valueTypes[prop->type]) {
-static_cast<QDeclarativeEnginePrivate *>(QObjectPrivate::get(engine));
-if (prop->type >= 0 /* QVariant == -1 */ && ep->valueTypes[prop->type]) {
 if (prop->values.count()) {
 if (prop->values.at(0)->location < prop->value->location) {
 COMPILE_EXCEPTION(prop->value, tr( "Property has already been assigned a value"));
 } else {
 if (!obj->metaObject()->property(prop->index).isWritable()) {
 COMPILE_EXCEPTION(prop, tr( "Invalid property assignment: \"%1\" is a read-only property").arg(QString::fromUtf8(prop->name)));
 }
-COMPILE_CHECK(buildValueTypeProperty(ep->valueTypes[prop->type],
+COMPILE_CHECK(buildValueTypeProperty(enginePrivate->valueTypes[prop->type],
 prop->value, obj, ctxt.incr()));
 obj->addValueTypeProperty(prop);
 } else {
 COMPILE_EXCEPTION(prop, tr("Invalid grouped property access"));
 }
 foreach (Property *prop, obj->properties) {
 int idx = type->metaObject()->indexOfProperty(prop->name.constData());
 if (idx == -1)
 COMPILE_EXCEPTION(prop, tr("Cannot assign to non-existent property \"%1\"").arg(QString::fromUtf8(prop->name)));
 QMetaProperty p = type->metaObject()->property(idx);
+if (!p.isScriptable())
+COMPILE_EXCEPTION(prop, tr("Cannot assign to non-existent property \"%1\"").arg(QString::fromUtf8(prop->name)));
 prop->index = idx;
 prop->type = p.userType();
 prop->isValueTypeSubProperty = true;
 if (prop->value)
 if (parts.count() != 2)
 return true;
 QString typeName = parts.at(0);
 QDeclarativeType *type = 0;
-enginePrivate->importDatabase.resolveType(unit->imports, typeName.toUtf8(),
+unit->imports().resolveType(typeName.toUtf8(), &type, 0, 0, 0, 0);
-&type, 0, 0, 0, 0);
 if (!type || obj->typeName != type->qmlTypeName())
 return true;
 QString enumValue = parts.at(1);
 int QDeclarativeCompiler::evaluateEnum(const QByteArray& script) const
 {
 int dot = script.indexOf('.');
 if (dot > 0) {
 QDeclarativeType *type = 0;
-enginePrivate->importDatabase.resolveType(unit->imports, script.left(dot), &type, 0, 0, 0, 0);
+unit->imports().resolveType(script.left(dot), &type, 0, 0, 0, 0);
 if (!type)
 return -1;
 const QMetaObject *mo = type->metaObject();
 const char *key = script.constData() + dot+1;
 int i = mo->enumeratorCount();
 }
 const QMetaObject *QDeclarativeCompiler::resolveType(const QByteArray& name) const
 {
 QDeclarativeType *qmltype = 0;
-if (!enginePrivate->importDatabase.resolveType(unit->imports, name, &qmltype,
+if (!unit->imports().resolveType(name, &qmltype, 0, 0, 0, 0))
-0, 0, 0, 0))
 return 0;
 if (!qmltype)
 return 0;
 return qmltype->metaObject();
 }
 }
 if (propNames.contains(prop.name))
 COMPILE_EXCEPTION(&prop, tr("Duplicate property name"));
-if (QString::fromUtf8(prop.name).at(0).isUpper())
+QString propName = QString::fromUtf8(prop.name);
+if (propName.at(0).isUpper())
 COMPILE_EXCEPTION(&prop, tr("Property names cannot begin with an upper case letter"));
-if (QDeclarativeEnginePrivate::get(engine)->globalClass->illegalNames().contains(prop.name))
+if (enginePrivate->globalClass->illegalNames().contains(propName))
 COMPILE_EXCEPTION(&prop, tr("Illegal property name"));
 propNames.insert(prop.name);
 }
 for (int ii = 0; ii < obj->dynamicSignals.count(); ++ii) {
 QByteArray name = obj->dynamicSignals.at(ii).name;
 if (methodNames.contains(name))
 COMPILE_EXCEPTION(obj, tr("Duplicate signal name"));
-if (QString::fromUtf8(name).at(0).isUpper())
+QString nameStr = QString::fromUtf8(name);
+if (nameStr.at(0).isUpper())
 COMPILE_EXCEPTION(obj, tr("Signal names cannot begin with an upper case letter"));
-if (QDeclarativeEnginePrivate::get(engine)->globalClass->illegalNames().contains(name))
+if (enginePrivate->globalClass->illegalNames().contains(nameStr))
 COMPILE_EXCEPTION(obj, tr("Illegal signal name"));
 methodNames.insert(name);
 }
 for (int ii = 0; ii < obj->dynamicSlots.count(); ++ii) {
 QByteArray name = obj->dynamicSlots.at(ii).name;
 if (methodNames.contains(name))
 COMPILE_EXCEPTION(obj, tr("Duplicate method name"));
-if (QString::fromUtf8(name).at(0).isUpper())
+QString nameStr = QString::fromUtf8(name);
+if (nameStr.at(0).isUpper())
 COMPILE_EXCEPTION(obj, tr("Method names cannot begin with an upper case letter"));
-if (QDeclarativeEnginePrivate::get(engine)->globalClass->illegalNames().contains(name))
+if (enginePrivate->globalClass->illegalNames().contains(nameStr))
 COMPILE_EXCEPTION(obj, tr("Illegal method name"));
 methodNames.insert(name);
 }
 return true;
 case Object::DynamicProperty::Custom:
 {
 QByteArray customTypeName;
 QDeclarativeType *qmltype = 0;
 QUrl url;
-if (!enginePrivate->importDatabase.resolveType(unit->imports, p.customType, &qmltype,
+if (!unit->imports().resolveType(p.customType, &qmltype, &url, 0, 0, 0))
-&url, 0, 0, 0))
 COMPILE_EXCEPTION(&p, tr("Invalid property type"));
 if (!qmltype) {
-QDeclarativeCompositeTypeData *tdata = enginePrivate->typeManager.get(url);
+QDeclarativeTypeData *tdata = enginePrivate->typeLoader.get(url);
 Q_ASSERT(tdata);
-Q_ASSERT(tdata->status == QDeclarativeCompositeTypeData::Complete);
+Q_ASSERT(tdata->isComplete());
-QDeclarativeCompiledData *data = tdata->toCompiledComponent(engine);
+QDeclarativeCompiledData *data = tdata->compiledData();
 customTypeName = data->root->className();
+data->release();
+tdata->release();
 } else {
 customTypeName = qmltype->typeName();
 }
 if (p.type == Object::DynamicProperty::Custom) {
 dynamicData.append((char *)&propertyData, sizeof(propertyData));
 builder.addSignal(p.name + "Changed()");
 QMetaPropertyBuilder propBuilder =
 builder.addProperty(p.name, type, builder.methodCount() - 1);
-propBuilder.setScriptable(true);
 propBuilder.setWritable(!readonly);
 }
-if (mode == ResolveAliases) {
+for (int ii = 0; ii < obj->dynamicProperties.count(); ++ii) {
-for (int ii = 0; ii < obj->dynamicProperties.count(); ++ii) {
+const Object::DynamicProperty &p = obj->dynamicProperties.at(ii);
-const Object::DynamicProperty &p = obj->dynamicProperties.at(ii);
+if (p.type == Object::DynamicProperty::Alias) {
-if (p.type == Object::DynamicProperty::Alias) {
+if (mode == ResolveAliases) {
 ((QDeclarativeVMEMetaData *)dynamicData.data())->aliasCount++;
 compileAlias(builder, dynamicData, obj, p);
+} else {
+// Need a fake signal so that the metaobject remains consistent across
+// the resolve and non-resolve alias runs
+builder.addSignal(p.name + "Changed()");
 }
 }
 }
 for (int ii = 0; ii < obj->dynamicSignals.count(); ++ii) {
 if (-1 == propIdx)
 COMPILE_EXCEPTION(prop.defaultValue, tr("Invalid alias location"));
 QMetaProperty aliasProperty = idObject->metaObject()->property(propIdx);
+if (!aliasProperty.isScriptable())
+COMPILE_EXCEPTION(prop.defaultValue, tr("Invalid alias location"));
 writable = aliasProperty.isWritable();
 if (aliasProperty.isEnumType())
 typeName = "int";  // Avoid introducing a dependency on the aliased metaobject
 else
 data.append((const char *)&flags, sizeof(flags));
 builder.addSignal(prop.name + "Changed()");
 QMetaPropertyBuilder propBuilder =
 builder.addProperty(prop.name, typeName.constData(), builder.methodCount() - 1);
-propBuilder.setScriptable(true);
 propBuilder.setWritable(writable);
 return true;
 }
 bool QDeclarativeCompiler::buildBinding(QDeclarativeParser::Value *value,
 BindingReference &binding = *iter;
 expr.context = binding.bindingContext.object;
 expr.property = binding.property;
 expr.expression = binding.expression;
-expr.imports = unit->imports;
+expr.imports = unit->imports();
 int index = bindingCompiler.compile(expr, enginePrivate);
 if (index != -1) {
 binding.dataType = BindingReference::Experimental;
 binding.compiledIndex = index;
 // ### Optimize
 QDeclarativeRewrite::SharedBindingTester sharableTest;
 bool isSharable = sharableTest.isSharable(expression);
 QDeclarativeRewrite::RewriteBinding rewriteBinding;
+rewriteBinding.setName('$'+binding.property->name);
 expression = rewriteBinding(expression);
 quint32 length = expression.length();
 quint32 pc;

changeset 37	758a864f9613
parent 33	3e2da88830cd