Differential D3427 Diff 8330 duchain/expressionvisitor.cpp

Changeset View

Standalone View

duchain/expressionvisitor.cpp

Context not available.
366	void ExpressionVisitor::visitSubscript(SubscriptAst* node)	366		void ExpressionVisitor::visitSubscript(SubscriptAst* node)
367	{	367		{
368	AstDefaultVisitor::visitNode(node->value);	368		AstDefaultVisitor::visitNode(node->value);
369	if ( node->slice && node->slice->astType == Ast::IndexAstType ) {	369
370	DUChainReadLocker lock;	370		AbstractType::Ptr result(new IntegralType(IntegralType::TypeMixed));
371	auto indexedTypes = Helper::filterType<IndexedContainer>(lastType(), [](AbstractType::Ptr toFilter) {	371		QVector<AbstractType::Ptr> valueTypes;
372	return toFilter.cast<IndexedContainer>();	372
373	});	373		if ( auto unsure = lastType().cast<UnsureType>() ) {
			brauchUnsubmitted Not Done You could replace this whole if/else by auto valueTypes = Helper::filterType(type, []() { return true; }); if you wanted. By the way, feel free to replace any QList you find anywhere by QVector ... it's a relict. brauch: You could replace this whole if/else by auto valueTypes = Helper::filterType(type, []() {…
374	for ( IndexedContainer::Ptr indexed: indexedTypes ) {	374		FOREACH_FUNCTION ( const auto& type, unsure->types ) {
375	// TODO This loop currently only uses the first result, it could construct	375		valueTypes << type.abstractType();
376	// an unsure from all the matches.	376		}
		377		} else {
		378		valueTypes << lastType();
		379		}
		380
		381		foreach (const auto& type, valueTypes) {
		382		if ( (node->slice && node->slice->astType != Ast::IndexAstType) &&
		383		(type.cast<IndexedContainer>() \|\| type.cast<ListType>()) ) {
		384		if ( type.cast<MapType>() ) {
		385		continue; // Can't slice dicts.
		386		}
		387		// Assume that slicing (e.g. foo[3:5]) a tuple/list returns the same type.
		388		// TODO: we could do better for some tuple slices.
		389		result = Helper::mergeTypes(result, type);
		390		}
		391		else if ( const auto& indexed = type.cast<IndexedContainer>() ) {
377	IndexAst* sliceIndexAst = static_cast<IndexAst*>(node->slice);	392		IndexAst* sliceIndexAst = static_cast<IndexAst*>(node->slice);
378	NumberAst* number = nullptr;	393		NumberAst* number = nullptr;
379	bool invert = false;	394		bool invert = false;
Context not available.
394	sliceIndex += indexed->typesCount();	409		sliceIndex += indexed->typesCount();
395	}	410		}
396	if ( sliceIndex < indexed->typesCount() && sliceIndex >= 0 ) {	411		if ( sliceIndex < indexed->typesCount() && sliceIndex >= 0 ) {
397	return encounter(indexed->typeAt(sliceIndex).abstractType());	412		result = Helper::mergeTypes(result, indexed->typeAt(sliceIndex).abstractType());
		413		continue;
398	}	414		}
399	}	415		}
400	// the exact index is unknown, use unsure	416		result = Helper::mergeTypes(result, indexed->asUnsureType());
401	return encounter(indexed->asUnsureType().cast<AbstractType>());	417		}
402	}	418		else if ( const auto& listType = type.cast<ListType>() ) {
403	auto variableTypes = Helper::filterType<ListType>(lastType(), [](AbstractType::Ptr toFilter) {	419		result = Helper::mergeTypes(result, listType->contentType().abstractType());
404	return toFilter.cast<ListType>();	420		}
405	});	421		else {
406	if ( ! variableTypes.isEmpty() ) {	422		// Type wasn't one with custom handling, so use return type of __getitem__().
407	AbstractType::Ptr result(new IntegralType(IntegralType::TypeMixed));	423		DUChainReadLocker lock;
408	for ( auto variable: variableTypes ) {	424		Declaration* function = Helper::accessAttribute(type, "__getitem__", context());
409	result = Helper::mergeTypes(result, variable->contentType().abstractType());	425		if ( function && function->isFunctionDeclaration() ) {
		426		if ( FunctionType::Ptr functionType = function->type<FunctionType>() ) {
		427		result = Helper::mergeTypes(result, functionType->returnType());
		428		}
410	}	429		}
411	return encounter(result);
412	}	430		}
413	}	431		}
414		432		encounter(result);
415	// If that does not work and we have a slice like [3:5], guess it will remain the same type.
416	// That is an approximation we have to make now, should optimally be corrected later.
417	// The reason is that we'd need to parse decorators from the __getitem__ method to support
418	// list/dict/etc properly otherwise, which requires a bit of refactoring first. TODO do this
419	if ( node->slice && node->slice->astType != Ast::IndexAstType ) {
420	return;
421	}
422
423	// Otherwise, try to use __getitem__.
424	DUChainReadLocker lock;
425	Declaration* function = Helper::accessAttribute(lastType(), "__getitem__", context());
426	if ( function && function->isFunctionDeclaration() ) {
427	if ( FunctionType::Ptr functionType = function->type<FunctionType>() ) {
428	return encounter(functionType->returnType());
429	}
430	}
431
432	// Otherwise, give up
433	return encounterUnknown();
434	}	433		}
435		434
436	void ExpressionVisitor::visitList(ListAst* node)	435		void ExpressionVisitor::visitList(ListAst* node)
Context not available.