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)); }