private CsdlRecordExpression OnRecordElement(XmlElementInfo element, XmlElementValueCollection childValues)
{
string type = OptionalQualifiedName(CsdlConstants.Attribute_Type);
IEnumerable <CsdlPropertyValue> propertyValues = childValues.ValuesOfType <CsdlPropertyValue>();
return(new CsdlRecordExpression(type != null ? new CsdlNamedTypeReference(type, false, element.Location) : null, propertyValues, element.Location));
}
private CsdlPropertyValue OnPropertyValueElement(XmlElementInfo element, XmlElementValueCollection childValues)
{
string property = Required(CsdlConstants.Attribute_Property);
CsdlExpressionBase expression = this.ParseAnnotationExpression(element, childValues);
return(new CsdlPropertyValue(property, expression, element.Location));
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindFirstAncestorOrSelf(root, context.Span, out XmlNodeSyntax xmlNode, findInsideTrivia: true))
{
return;
}
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case DiagnosticIdentifiers.UnusedElementInDocumentationComment:
{
XmlElementInfo elementInfo = SyntaxInfo.XmlElementInfo(xmlNode);
string name = elementInfo.LocalName;
CodeAction codeAction = CodeAction.Create(
$"Remove element '{name}'",
cancellationToken => RemoveUnusedElementInDocumentationCommentAsync(context.Document, elementInfo, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
}
}
}
private CsdlTypeReference OnCollectionTypeElement(XmlElementInfo element, XmlElementValueCollection childValues)
{
string elementTypeName = OptionalType(CsdlConstants.Attribute_ElementType);
CsdlTypeReference elementType = this.ParseTypeReference(elementTypeName, childValues, element.Location, Optionality.Required);
return(new CsdlExpressionTypeReference(new CsdlCollectionType(elementType, element.Location), elementType.IsNullable, element.Location));
}
private CsdlInclude OnIncludeElement(XmlElementInfo element, XmlElementValueCollection childValues)
{
string nameSp = Required(CsdlConstants.Attribute_Namespace);
string alias = Optional(CsdlConstants.Attribute_Alias);
return(new CsdlInclude(alias, nameSp, element.Location));
}
private CsdlNavigationPropertyBinding OnNavigationPropertyBindingElement(XmlElementInfo element, XmlElementValueCollection childValues)
{
string path = Required(CsdlConstants.Attribute_Path);
string entitySet = Required(CsdlConstants.Attribute_Target);
return(new CsdlNavigationPropertyBinding(path, entitySet, element.Location));
}
private string GetUrl(XmlElementInfo xmlElementInfo)
{
var currentUrl = xmlElementInfo?.NamespaceUri;
var topUrl = namespacesStack.Count > 0 ? namespacesStack.Peek() : string.Empty;
return(string.IsNullOrEmpty(currentUrl) ? topUrl : currentUrl);
}
private CsdlOperationReturn OnReturnTypeElement(XmlElementInfo element, XmlElementValueCollection childValues)
{
string typeName = RequiredType(CsdlConstants.Attribute_Type);
CsdlTypeReference type = this.ParseTypeReference(typeName, childValues, element.Location, Optionality.Required);
return(new CsdlOperationReturn(type, element.Location));
}
private CsdlSingleton OnSingletonElement(XmlElementInfo element, XmlElementValueCollection childValues)
{
string name = Required(CsdlConstants.Attribute_Name);
string type = RequiredQualifiedName(CsdlConstants.Attribute_Type);
return(new CsdlSingleton(name, type, childValues.ValuesOfType <CsdlNavigationPropertyBinding>(), element.Location));
}
private CsdlReferentialConstraint OnReferentialConstraintElement(XmlElementInfo element, XmlElementValueCollection childValues)
{
string propertyName = this.Required(CsdlConstants.Attribute_Property);
string referencedPropertyName = this.Required(CsdlConstants.Attribute_ReferencedProperty);
return(new CsdlReferentialConstraint(propertyName, referencedPropertyName, element.Location));
}
private CsdlApplyExpression OnApplyElement(XmlElementInfo element, XmlElementValueCollection childValues)
{
string function = Optional(CsdlConstants.Attribute_Function);
IEnumerable <CsdlExpressionBase> arguments = childValues.ValuesOfType <CsdlExpressionBase>();
return(new CsdlApplyExpression(function, arguments, element.Location));
}
private CsdlEnumMember OnEnumMemberElement(XmlElementInfo element, XmlElementValueCollection childValues)
{
string name = Required(CsdlConstants.Attribute_Name);
long? value = OptionalLong(CsdlConstants.Attribute_Value);
return(new CsdlEnumMember(name, value, element.Location));
}
private CsdlTypeDefinition OnTypeDefinitionElement(XmlElementInfo element, XmlElementValueCollection childValues)
{
string name = Required(CsdlConstants.Attribute_Name);
string underlyingTypeName = RequiredType(CsdlConstants.Attribute_UnderlyingType);
return(new CsdlTypeDefinition(name, underlyingTypeName, element.Location));
}
private CsdlIncludeAnnotations OnIncludeAnnotationsElement(XmlElementInfo element, XmlElementValueCollection childValues)
{
string termNamespace = Required(CsdlConstants.Attribute_TermNamespace);
string qualifier = Optional(CsdlConstants.Attribute_Qualifier);
string targetNamespace = Optional(CsdlConstants.Attribute_TargetNamespace);
return(new CsdlIncludeAnnotations(termNamespace, qualifier, targetNamespace, element.Location));
}
private CsdlOperationParameter OnFunctionImportParameterElement(XmlElementInfo element, XmlElementValueCollection childValues)
{
string name = Required(CsdlConstants.Attribute_Name);
string typeName = RequiredType(CsdlConstants.Attribute_Type);
CsdlTypeReference type = this.ParseTypeReference(typeName, null, element.Location, Optionality.Required);
return(new CsdlOperationParameter(name, type, element.Location));
}
private CsdlAnnotation OnAnnotationElement(XmlElementInfo element, XmlElementValueCollection childValues)
{
string term = RequiredQualifiedName(CsdlConstants.Attribute_Term);
string qualifier = Optional(CsdlConstants.Attribute_Qualifier);
CsdlExpressionBase expression = this.ParseAnnotationExpression(element, childValues);
return(new CsdlAnnotation(term, qualifier, expression, element.Location));
}
private CsdlActionImport OnActionImportElement(XmlElementInfo element, XmlElementValueCollection childValues)
{
string name = Required(CsdlConstants.Attribute_Name);
string qualifiedActionName = RequiredQualifiedName(CsdlConstants.Attribute_Action);
string entitySet = Optional(CsdlConstants.Attribute_EntitySet);
return(new CsdlActionImport(name, qualifiedActionName, entitySet, element.Location));
}
private CsdlEnumType OnEnumTypeElement(XmlElementInfo element, XmlElementValueCollection childValues)
{
string name = Required(CsdlConstants.Attribute_Name);
string underlyingType = OptionalType(CsdlConstants.Attribute_UnderlyingType);
bool? isFlags = OptionalBoolean(CsdlConstants.Attribute_IsFlags);
return(new CsdlEnumType(name, underlyingType, isFlags ?? false, childValues.ValuesOfType <CsdlEnumMember>(), element.Location));
}
private CsdlAnnotations OnAnnotationsElement(XmlElementInfo element, XmlElementValueCollection childValues)
{
string target = Required(CsdlConstants.Attribute_Target);
string qualifier = Optional(CsdlConstants.Attribute_Qualifier);
IEnumerable <CsdlAnnotation> annotations = childValues.ValuesOfType <CsdlAnnotation>();
return(new CsdlAnnotations(annotations, target, qualifier));
}
private CsdlCollectionExpression OnCollectionElement(XmlElementInfo element, XmlElementValueCollection childValues)
{
string typeName = OptionalType(CsdlConstants.Attribute_Type);
CsdlTypeReference type = this.ParseTypeReference(typeName, childValues, element.Location, Optionality.Optional);
IEnumerable <CsdlExpressionBase> elementValues = childValues.ValuesOfType <CsdlExpressionBase>();
return(new CsdlCollectionExpression(type, elementValues, element.Location));
}
private CsdlProperty OnPropertyElement(XmlElementInfo element, XmlElementValueCollection childValues)
{
string typeName = OptionalType(CsdlConstants.Attribute_Type);
CsdlTypeReference type = this.ParseTypeReference(typeName, childValues, element.Location, Optionality.Required);
string name = Required(CsdlConstants.Attribute_Name);
string defaultValue = Optional(CsdlConstants.Attribute_DefaultValue);
return(new CsdlProperty(name, type, defaultValue, element.Location));
}
private static void Analyze <TNode>(
SyntaxNodeAnalysisContext context,
SyntaxList <XmlNodeSyntax> xmlNodes,
SeparatedSyntaxList <TNode> nodes,
XmlTag tag,
Func <SeparatedSyntaxList <TNode>, string, int> indexOf) where TNode : SyntaxNode
{
XmlNodeSyntax firstElement = null;
int firstIndex = -1;
for (int i = 0; i < xmlNodes.Count; i++)
{
XmlElementInfo elementInfo = SyntaxInfo.XmlElementInfo(xmlNodes[i]);
if (!elementInfo.Success)
{
continue;
}
if (!elementInfo.HasTag(tag))
{
firstIndex = -1;
continue;
}
XmlNodeSyntax element = elementInfo.Element;
string name = (element.IsKind(SyntaxKind.XmlElement))
? ((XmlElementSyntax)element).GetAttributeValue("name")
: ((XmlEmptyElementSyntax)element).GetAttributeValue("name");
if (name == null)
{
firstIndex = -1;
continue;
}
int index = indexOf(nodes, name);
if (index == -1)
{
ReportUnusedElement(context, element, i, xmlNodes);
}
else if (index < firstIndex)
{
ReportDiagnosticIfNotSuppressed(context, DiagnosticRules.OrderElementsInDocumentationComment, firstElement);
return;
}
else
{
firstElement = element;
}
firstIndex = index;
}
}
private CsdlFunctionImport OnFunctionImportElement(XmlElementInfo element, XmlElementValueCollection childValues)
{
string name = Required(CsdlConstants.Attribute_Name);
string qualifiedActionName = RequiredQualifiedName(CsdlConstants.Attribute_Function);
string entitySet = Optional(CsdlConstants.Attribute_EntitySet);
bool includeInServiceDocument = OptionalBoolean(CsdlConstants.Attribute_IncludeInServiceDocument) ?? CsdlConstants.Default_IncludeInServiceDocument;
return(new CsdlFunctionImport(name, qualifiedActionName, entitySet, includeInServiceDocument, element.Location));
}
private CsdlComplexType OnComplexTypeElement(XmlElementInfo element, XmlElementValueCollection childValues)
{
string name = Required(CsdlConstants.Attribute_Name);
string baseType = OptionalQualifiedName(CsdlConstants.Attribute_BaseType);
bool isOpen = OptionalBoolean(CsdlConstants.Attribute_OpenType) ?? CsdlConstants.Default_OpenType;
bool isAbstract = OptionalBoolean(CsdlConstants.Attribute_Abstract) ?? CsdlConstants.Default_Abstract;
return(new CsdlComplexType(name, baseType, isAbstract, isOpen, childValues.ValuesOfType <CsdlProperty>(), childValues.ValuesOfType <CsdlNavigationProperty>(), element.Location));
}
private CsdlReference OnReferenceElement(XmlElementInfo element, XmlElementValueCollection childValues)
{
// read 'Uri' attribute
string uri = Required(CsdlConstants.Attribute_Uri);
return(new CsdlReference(uri,
childValues.ValuesOfType <CsdlInclude>(),
childValues.ValuesOfType <CsdlIncludeAnnotations>(),
element.Location));
}
private string GetXmlElementString(XmlElementInfo xmlElementInfo)
{
var url = GetUrl(xmlElementInfo);
var topUrl = namespacesStack.Count > 0 ? namespacesStack.Peek() : string.Empty;
if (string.IsNullOrEmpty(url) || url == topUrl)
{
return(xmlElementInfo.Name);
}
return("[" + url + "]" + xmlElementInfo.Name);
}
private CsdlEntityType OnEntityTypeElement(XmlElementInfo element, XmlElementValueCollection childValues)
{
string name = Required(CsdlConstants.Attribute_Name);
string baseType = OptionalQualifiedName(CsdlConstants.Attribute_BaseType);
bool isOpen = OptionalBoolean(CsdlConstants.Attribute_OpenType) ?? CsdlConstants.Default_OpenType;
bool isAbstract = OptionalBoolean(CsdlConstants.Attribute_Abstract) ?? CsdlConstants.Default_Abstract;
bool hasStream = OptionalBoolean(CsdlConstants.Attribute_HasStream) ?? CsdlConstants.Default_HasStream;
CsdlKey key = childValues.ValuesOfType <CsdlKey>().FirstOrDefault();
return(new CsdlEntityType(name, baseType, isAbstract, isOpen, hasStream, key, childValues.ValuesOfType <CsdlProperty>(), childValues.ValuesOfType <CsdlNavigationProperty>(), element.Location));
}
private static void AnalyzeList(SyntaxNodeAnalysisContext context, XmlElementInfo elementInfo)
{
if (elementInfo.IsEmptyElement)
{
return;
}
var element = (XmlElementSyntax)elementInfo.Element;
foreach (XmlNodeSyntax node in element.Content)
{
XmlElementInfo elementInfo2 = SyntaxInfo.XmlElementInfo(node);
if (!elementInfo2.Success)
{
continue;
}
if (elementInfo2.IsEmptyElement)
{
continue;
}
if (!elementInfo2.HasLocalName("listheader", "item"))
{
continue;
}
var element2 = (XmlElementSyntax)elementInfo2.Element;
foreach (XmlNodeSyntax node2 in element2.Content)
{
XmlElementInfo elementInfo3 = SyntaxInfo.XmlElementInfo(node2);
if (!elementInfo3.Success)
{
continue;
}
if (elementInfo3.IsEmptyElement)
{
continue;
}
if (elementInfo3.HasLocalName("term", "description"))
{
Analyze(context, elementInfo3);
}
}
}
}
private bool CanBeRemoved(XmlElementInfo xmlElementInfo, bool isArrayElement)
{
if (collapseOnlyOptionalElements)
{
return(xmlElementInfo.Optional);
}
if (isArrayElement)
{
return(collapseArrayElements);
}
return(true);
}
private CsdlExpressionBase OnIsTypeExpression(XmlElementInfo element, XmlElementValueCollection childValues)
{
string typeName = OptionalType(CsdlConstants.Attribute_Type);
CsdlTypeReference type = this.ParseTypeReference(typeName, childValues, element.Location, Optionality.Required);
IEnumerable <CsdlExpressionBase> expressions = childValues.ValuesOfType <CsdlExpressionBase>();
if (expressions.Count() != 1)
{
this.ReportError(element.Location, EdmErrorCode.InvalidIsTypeExpressionIncorrectNumberOfOperands, Edm.Strings.CsdlParser_InvalidIsTypeExpressionIncorrectNumberOfOperands);
}
return(new CsdlIsTypeExpression(type, expressions.ElementAtOrDefault(0), element.Location));
}
