public IEnumerable <SuggestItem> Suggest()
{
if (_targetElement == null || _lastAttribute == null)
{
return(Enumerable.Empty <SuggestItem>());
}
if (_lastAttribute.NamespacePrefix == "ux" && _parentElement != null)
{
return(new StandardAttributesSuggestion(_dataTypes, _targetElement, _parentElement,
_lastAttribute.FullName, _codeReader, _namespaceDeclarations).Suggest());
}
var dataType = _targetElement.ToDataType(_dataTypes.AccessibleUxTypes, _namespaceDeclarations);
if (dataType == null)
{
return(Enumerable.Empty <SuggestItem>());
}
var properties = PropertyHelper.GetAllWriteableProperties(dataType);
var lastAttributeProperty = properties.FirstOrDefault(p => _lastAttribute.Name == p.Name);
if (lastAttributeProperty == null)
{
return(Enumerable.Empty <SuggestItem>());
}
return(SuggestValuesForProperty(lastAttributeProperty));
}
public IEnumerable <SuggestItem> Suggest()
{
if (_elementContext == null)
{
return(Enumerable.Empty <SuggestItem>());
}
var suggestItems = PossibleStandardAttribs();
var dataType = _elementContext.ToDataType(_dataTypes.AccessibleUxTypes, _namespaceDeclarations);
if (dataType == null)
{
return(suggestItems);
}
var possibleArguments = Task.Run(() => PossibleArguments(dataType));
var possibleProperties = Task.Run(() => PossibleProperties(dataType));
var possibleEvents = Task.Run(() => PossibleEvents(dataType));
return(suggestItems
.Concat(possibleArguments.Result)
.Concat(possibleProperties.Result)
.Concat(possibleEvents.Result));
}
IEnumerable <SuggestItem> SuggestBindingValues()
{
var dataType = _parentElement.ToDataType(_dataTypes.AccessibleUxTypes, _namespaces);
if (dataType == null)
{
return(null);
}
var properties = PropertyHelper.GetAllWriteableProperties(dataType);
return(properties.Select(p => SuggestionHelper.Suggest(SuggestItemType.Property, p, p.Name)));
}
IEnumerable <SuggestItem> SuggestReferenceValue()
{
var nameAttributes = FindUXNameAttributes(_codeReader);
var namesToDataTypes = ResolveNamesAndTypes(_dataTypes, nameAttributes, _namespaces);
var elementDataType = _targetElement.ToDataType(_dataTypes.AccessibleUxTypes, _namespaces);
if (elementDataType == null)
{
return(null);
}
return(namesToDataTypes.Where(d => d.Value == elementDataType).Select(n => SuggestionHelper.Suggest(SuggestItemType.Variable, n.Value, n.Key)));
}
public IEnumerable <SuggestItem> Suggest()
{
if (_parentElement == null)
{
var dataTypes = DataTypeHelper.GetDataTypesForElement(_targetElement, _dataTypes, _namespaceDeclarations);
return(ConvertNamescopesToSuggestions(dataTypes));
}
var allTypes = _dataTypes.AccessibleUxTypes;
var concreteTypes = allTypes.Where(dataType => !dataType.Modifiers.HasFlag(Modifiers.Abstract))
.ToArray();
var parentDataType = _parentElement.ToDataType(_parentElement.Name == "App" ? allTypes : concreteTypes, _namespaceDeclarations);
if (parentDataType == null)
{
return(Enumerable.Empty <SuggestItem>());
}
var parentPublicProperties = Task.Run(() => PropertyHelper.GetAllComponentPrimaryOrContentProperties(parentDataType));
var hasPrefix = HasTargetNamespacePrefix();
if (hasPrefix)
{
return(HandleNamespacePrefix(concreteTypes, parentPublicProperties));
}
var ns = DataTypeHelper.GetQualifiedNamespaceForElement(_targetElement);
var types = HandleNonNamespacePrefix(DataTypeHelper.GetDataTypesForElement(_targetElement, _dataTypes, _namespaceDeclarations).ToArray(), parentPublicProperties);
if (ns != null)
{
return(types.Concat(ConvertNamescopesToSuggestions(GetNamespacesInNamespace(ns))));
}
else
{
return(types
.Concat(ConvertNamescopesToSuggestions(GetNamespacesInRoot()))
.Concat(_namespaceDeclarations.Values.Where(nss => nss != "")
.Select(nss => SuggestionHelper.Suggest(SuggestItemType.Namespace, null, nss + ":"))));
}
}
