private static async Task <Document> GetDocument(string code, bool withAnnotations) { var ws = new AdhocWorkspace(); var emptyProject = ws.AddProject( ProjectInfo.Create( ProjectId.CreateNewId(), VersionStamp.Default, "test", "test.dll", LanguageNames.CSharp, metadataReferences: new[] { TestMetadata.Net451.mscorlib })); var doc = emptyProject.AddDocument("test.cs", code); if (withAnnotations) { var root = await doc.GetSyntaxRootAsync(); var model = await doc.GetSemanticModelAsync(); root = root.ReplaceNodes(root.DescendantNodesAndSelf().OfType <TypeSyntax>(), (o, c) => { var symbol = model.GetSymbolInfo(o).Symbol; return(symbol != null ? c.WithAdditionalAnnotations(SymbolAnnotation.Create(symbol), Simplifier.Annotation) : c); }); doc = doc.WithSyntaxRoot(root); } return(doc); }
public void AddCast( ISyntaxFacts syntaxFacts, SemanticModel semanticModel, SyntaxEditor editor, TForEachStatementSyntax forEachStatement, CancellationToken cancellationToken) { var expression = syntaxFacts.GetExpressionOfForeachStatement(forEachStatement); var loopOperation = (IForEachLoopOperation)semanticModel.GetRequiredOperation(forEachStatement, cancellationToken); var variableDeclarator = (IVariableDeclaratorOperation)loopOperation.LoopControlVariable; var enumerableType = semanticModel.Compilation.GetBestTypeByMetadataName(typeof(Enumerable).FullName !); // These were already verified to be non-null in the analyzer. Contract.ThrowIfNull(variableDeclarator.Symbol.Type); Contract.ThrowIfNull(enumerableType); var elementType = GetForEachElementType(semanticModel, forEachStatement); var conversion = semanticModel.Compilation.ClassifyCommonConversion(elementType, variableDeclarator.Symbol.Type); var rewritten = GetRewrittenCollection(editor.Generator, expression, variableDeclarator.Symbol.Type, conversion); // Add an annotation for System.Linq.Enumerable so that we add a `using System.Linq;` if not present. rewritten = rewritten.WithAdditionalAnnotations( Simplifier.Annotation, Simplifier.AddImportsAnnotation, SymbolAnnotation.Create(enumerableType)); editor.ReplaceNode(expression, rewritten); }
private void TestSymbolSerialization(Document document, string symbolName) { var model = document.GetSemanticModelAsync().Result; var name = CS.SyntaxFactory.ParseName(symbolName); var symbol = model.GetSpeculativeSymbolInfo(0, name, SpeculativeBindingOption.BindAsExpression).Symbol; var root = (CS.Syntax.CompilationUnitSyntax)model.SyntaxTree.GetRoot(); var annotation = SymbolAnnotation.Create(symbol); var rootWithAnnotation = root.WithAdditionalAnnotations(annotation); Assert.Equal(true, rootWithAnnotation.ContainsAnnotations); Assert.Equal(true, rootWithAnnotation.HasAnnotation(annotation)); var stream = new MemoryStream(); rootWithAnnotation.SerializeTo(stream); stream.Position = 0; var droot = CS.CSharpSyntaxNode.DeserializeFrom(stream); Assert.Equal(true, droot.ContainsAnnotations); Assert.Equal(true, droot.HasAnnotation(annotation)); var dannotation = droot.GetAnnotations(SymbolAnnotation.Kind).SingleOrDefault(); Assert.NotNull(dannotation); Assert.NotSame(annotation, dannotation); Assert.Equal(annotation, dannotation); var id = SymbolAnnotation.GetSymbol(annotation, model.Compilation); var did = SymbolAnnotation.GetSymbol(dannotation, model.Compilation); Assert.Equal(true, id.Equals(did)); }
public MGLAnnotationView MapView_ViewForAnnotation(MGLMapView mapView, IMGLAnnotation annotation) { var fannotation = Element.Annotations.FirstOrDefault(x => x.NativeHandle == annotation.Handle); switch (fannotation) { case SymbolAnnotation symbol: if (symbol.IconImage?.Source != null) { return null; } break; } var annotationView = mapView.DequeueReusableAnnotationViewWithIdentifier("draggablePoint"); if (annotationView != null) return annotationView; var view = new DraggableAnnotationView(reuseIdentifier: "draggablePoint", size: 24); view.DragFinished += (sender, e) => { var point = new SymbolAnnotation(); point.NativeHandle = annotation.Handle; point.Coordinates = annotation.Coordinate.ToLatLng(); Element.DragFinishedCommand?.Execute(point); }; view.AddGestureRecognizer(new UITapGestureRecognizer(tap => { Element.DidTapOnMarkerCommand?.Execute(fannotation.Id); })); //mapView.SelectAnnotation(annotation, true, null); return view; }
public MGLAnnotationView MapView_ViewForAnnotation(MGLMapView mapView, IMGLAnnotation annotation) { var fannotation = Element.Annotations.FirstOrDefault(x => x.NativeHandle == annotation.Handle); switch (fannotation) { case SymbolAnnotation symbol: if (symbol.IconImage?.Source != null) { return(null); } break; } var annotationView = mapView.DequeueReusableAnnotationViewWithIdentifier("draggablePoint"); if (annotationView != null) { return(annotationView); } var view = new DraggableAnnotationView(reuseIdentifier: "draggablePoint", size: 24); view.DragFinished += (sender, e) => { var point = new SymbolAnnotation(); point.NativeHandle = annotation.Handle; point.Coordinates = annotation.Coordinate.ToLatLng(); Element.DragFinishedCommand?.Execute(point); }; return(view); }
private TTypeSyntax AddInformationTo <TTypeSyntax>(TTypeSyntax syntax, ISymbol symbol) where TTypeSyntax : TypeSyntax { syntax = syntax.WithPrependedLeadingTrivia(SyntaxFactory.ElasticMarker).WithAppendedTrailingTrivia(SyntaxFactory.ElasticMarker); syntax = syntax.WithAdditionalAnnotations(SymbolAnnotation.Create(symbol)); return(syntax); }
private void HandleStyleLoaded(MapStyle obj) { var symbol = new SymbolAnnotation { Coordinates = new LatLng(60.169091, 24.939876), IconImage = MAKI_ICON_HARBOR, IconSize = 2.0f, IsDraggable = true, Id = Guid.NewGuid().ToString() }; map.Annotations = new[] { symbol }; }
void HandleStyleLoaded(MapStyle obj) { IconImageSource iconImageSource = ImageSource.FromFile("red_marker.png"); /*map.Functions.AddStyleImage(iconImageSource); * * var symbolLayerIconFeatureList = new List<Feature>(); * symbolLayerIconFeatureList.Add( * new Feature(new GeoJSON.Net.Geometry.Point( * new GeoJSON.Net.Geometry.Position(-33.213144, -57.225365)))); * symbolLayerIconFeatureList.Add( * new Feature(new GeoJSON.Net.Geometry.Point( * new GeoJSON.Net.Geometry.Position(-33.981818, -54.14164)))); * symbolLayerIconFeatureList.Add( * new Feature(new GeoJSON.Net.Geometry.Point( * new GeoJSON.Net.Geometry.Position(-30.583266, -56.990533)))); * * var featureCollection = new FeatureCollection(symbolLayerIconFeatureList); * * var source = new GeoJsonSource * { * Id = "feature.memory.src", * Data = featureCollection * }; * map.Functions.AddSource(source); * * var symbolLayer = new SymbolLayer("feature.symbol.layer", source.Id) * { * IconAllowOverlap = Expression.Literal(true), * IconImage = Expression.Literal(iconImageSource.Id), * IconOffset = Expression.Literal(new[] { 0.0, -9.0 }) * }; * map.Functions.AddLayer(symbolLayer);*/ var symbol = new SymbolAnnotation { Coordinates = new LatLng(60.169091, 24.939876), IconImage = iconImageSource, IconSize = 2.0f, IsDraggable = true, Id = Guid.NewGuid().ToString() }; map.Annotations = new[] { symbol }; }
protected async Task <IDictionary <SyntaxNode, ISet <INamedTypeSymbol> > > GetAllReferencedDefinitionsAsync( Compilation compilation, IEnumerable <ISymbol> members, CancellationToken cancellationToken) { var namespaceScopeToReferencedDefinitions = new Dictionary <SyntaxNode, ISet <INamedTypeSymbol> >(); var root = await Document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); Func <SyntaxNode, ISet <INamedTypeSymbol> > createSet = _ => new HashSet <INamedTypeSymbol>(); var annotatedNodes = root.GetAnnotatedNodesAndTokens(SymbolAnnotation.Kind); foreach (var annotatedNode in annotatedNodes) { cancellationToken.ThrowIfCancellationRequested(); if (annotatedNode.GetAnnotations(DoNotAddImportsAnnotation.Kind).Any()) { continue; } SyntaxNode namespaceScope = null; var annotations = annotatedNode.GetAnnotations(SymbolAnnotation.Kind); foreach (var annotation in annotations) { cancellationToken.ThrowIfCancellationRequested(); foreach (var namedType in SymbolAnnotation.GetSymbols(annotation, compilation).OfType <INamedTypeSymbol>()) { cancellationToken.ThrowIfCancellationRequested(); if (!IsBuiltIn(namedType)) { namespaceScope = namespaceScope ?? this.GetInnermostNamespaceScope(annotatedNode); var referencedDefinitions = namespaceScopeToReferencedDefinitions.GetOrAdd( namespaceScope, createSet); referencedDefinitions.Add(namedType); } } } } return(namespaceScopeToReferencedDefinitions); }
private void AddMapMarker(object sender, EventArgs args) { try { var symbolAnnotation = new SymbolAnnotation { Coordinates = new LatLng(location.Latitude, location.Longitude), IconImage = (ImageSource)MARKER_ICON, IconSize = 1.0f, IsDraggable = false, Id = Guid.NewGuid().ToString() }; symbolAnnotations.Add(symbolAnnotation); Refresh(); } catch (Exception ex) { } }
private (ImmutableArray <SyntaxNode> imports, IEnumerable <INamespaceSymbol> namespaceSymbols, SyntaxNode?context) GetImportDirectivesFromAnnotatedNodes( IEnumerable <SyntaxNode> syntaxNodes, SyntaxNode root, SemanticModel model, IAddImportsService addImportsService, SyntaxGenerator generator, CancellationToken cancellationToken) { (SyntaxNode first, SyntaxNode last)? nodes = null; var importsToAdd = ArrayBuilder <SyntaxNode> .GetInstance(); var annotatedNodes = syntaxNodes.Where(x => x.HasAnnotations(SymbolAnnotation.Kind)); var addedSymbols = new HashSet <INamespaceSymbol>(); foreach (var annotatedNode in annotatedNodes) { cancellationToken.ThrowIfCancellationRequested(); if (annotatedNode.GetAnnotations(DoNotAddImportsAnnotation.Kind).Any()) { continue; } var annotations = annotatedNode.GetAnnotations(SymbolAnnotation.Kind); foreach (var annotation in annotations) { cancellationToken.ThrowIfCancellationRequested(); foreach (var namedType in SymbolAnnotation.GetSymbols(annotation, model.Compilation).OfType <INamedTypeSymbol>()) { cancellationToken.ThrowIfCancellationRequested(); if (namedType.OriginalDefinition.IsSpecialType() || namedType.IsNullable() || namedType.IsTupleType) { continue; } var namespaceSymbol = namedType.ContainingNamespace; if (namespaceSymbol is null || namespaceSymbol.IsGlobalNamespace) { continue; } nodes = (first : nodes?.first ?? annotatedNode, last : annotatedNode); if (addedSymbols.Contains(namespaceSymbol)) { continue; } var namespaceSyntax = GenerateNamespaceImportDeclaration(namespaceSymbol, generator); if (addImportsService.HasExistingImport(model.Compilation, root, annotatedNode, namespaceSyntax, generator)) { continue; } if (IsInsideNamespace(annotatedNode, namespaceSymbol, model, cancellationToken)) { continue; } addedSymbols.Add(namespaceSymbol); importsToAdd.Add(namespaceSyntax); } } } // we don't add simplifier annotations here, // since whatever added the symbol annotation probably also added simplifier annotations, // and if not they probably didn't for a reason return(importsToAdd.ToImmutableAndFree(), addedSymbols, nodes is var(first, last) ? first.GetCommonRoot(last) : null); }
private async Task <Document> AddImportDirectivesFromSymbolAnnotationsAsync( Document document, IEnumerable <SyntaxNode> syntaxNodes, IAddImportsService addImportsService, SyntaxGenerator generator, bool placeSystemNamespaceFirst, bool allowInHiddenRegions, CancellationToken cancellationToken) { using var _ = PooledDictionary <INamespaceSymbol, SyntaxNode> .GetInstance(out var importToSyntax); var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false); var model = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false); SyntaxNode?first = null, last = null; var annotatedNodes = syntaxNodes.Where(x => x.HasAnnotations(SymbolAnnotation.Kind)); foreach (var annotatedNode in annotatedNodes) { cancellationToken.ThrowIfCancellationRequested(); if (annotatedNode.GetAnnotations(DoNotAddImportsAnnotation.Kind).Any()) { continue; } var annotations = annotatedNode.GetAnnotations(SymbolAnnotation.Kind); foreach (var annotation in annotations) { cancellationToken.ThrowIfCancellationRequested(); foreach (var namedType in SymbolAnnotation.GetSymbols(annotation, model.Compilation).OfType <INamedTypeSymbol>()) { cancellationToken.ThrowIfCancellationRequested(); if (namedType.OriginalDefinition.IsSpecialType() || namedType.IsNullable() || namedType.IsTupleType) { continue; } var namespaceSymbol = namedType.ContainingNamespace; if (namespaceSymbol is null || namespaceSymbol.IsGlobalNamespace) { continue; } first ??= annotatedNode; last = annotatedNode; if (importToSyntax.ContainsKey(namespaceSymbol)) { continue; } var namespaceSyntax = GenerateNamespaceImportDeclaration(namespaceSymbol, generator); if (addImportsService.HasExistingImport(model.Compilation, root, annotatedNode, namespaceSyntax, generator)) { continue; } if (IsInsideNamespace(annotatedNode, namespaceSymbol, model, cancellationToken)) { continue; } importToSyntax[namespaceSymbol] = namespaceSyntax; } } } if (first == null || last == null || importToSyntax.Count == 0) { return(document); } var context = first.GetCommonRoot(last); // Find the namespace/compilation-unit we'll be adding all these imports to. var importContainer = addImportsService.GetImportContainer(root, context, importToSyntax.First().Value); // Now remove any imports we think can cause conflicts in that container. var safeImportsToAdd = GetSafeToAddImports(importToSyntax.Keys.ToImmutableArray(), importContainer, model, cancellationToken); var importsToAdd = importToSyntax.Where(kvp => safeImportsToAdd.Contains(kvp.Key)).Select(kvp => kvp.Value).ToImmutableArray(); if (importsToAdd.Length == 0) { return(document); } root = addImportsService.AddImports( model.Compilation, root, context, importsToAdd, generator, placeSystemNamespaceFirst, allowInHiddenRegions, cancellationToken); return(document.WithSyntaxRoot(root)); }
public static SymbolOptions ToSymbolOptions(this SymbolAnnotation symbolAnnotation) { var symbolOptions = new SymbolOptions() .WithLatLng(symbolAnnotation.Coordinates.ToLatLng()); if (!string.IsNullOrWhiteSpace(symbolAnnotation.IconAnchor)) { symbolOptions.WithIconImage(symbolAnnotation.IconAnchor); } if (symbolAnnotation.IconColor.HasValue) { symbolOptions.WithIconColor(symbolAnnotation.IconColor.Value.ToRGBAString()); } if (symbolAnnotation.IconHaloBlur.HasValue) { symbolOptions.WithIconHaloBlur(new Float(symbolAnnotation.IconHaloBlur.Value)); } if (symbolAnnotation.IconHaloColor.HasValue) { symbolOptions.WithIconHaloColor(symbolAnnotation.IconHaloColor.Value.ToRGBAString()); } if (symbolAnnotation.IconHaloWidth.HasValue) { symbolOptions.WithIconHaloWidth(new Float(symbolAnnotation.IconHaloWidth.Value)); } if (symbolAnnotation.IconImage != null) { symbolOptions.WithIconImage(symbolAnnotation.IconImage.Id); } if (symbolAnnotation.IconOffset?.Length > 0) { symbolOptions.WithIconOffset(symbolAnnotation.IconOffset.Select(x => new Float(x)).ToArray()); } if (symbolAnnotation.IconOpacity.HasValue) { symbolOptions.WithIconOpacity(new Float(symbolAnnotation.IconOpacity.Value)); } if (symbolAnnotation.IconRotate.HasValue) { symbolOptions.WithIconRotate(new Float(symbolAnnotation.IconRotate.Value)); } if (symbolAnnotation.IconSize.HasValue) { symbolOptions.WithIconSize(new Float(symbolAnnotation.IconSize.Value)); } if (symbolAnnotation.IsDraggable.HasValue) { symbolOptions.WithDraggable(symbolAnnotation.IsDraggable.Value); } if (symbolAnnotation.SymbolSortKey.HasValue) { symbolOptions.WithSymbolSortKey(new Float(symbolAnnotation.SymbolSortKey.Value)); } if (!string.IsNullOrWhiteSpace(symbolAnnotation.TextAnchor)) { symbolOptions.WithTextAnchor(symbolAnnotation.TextAnchor); } if (symbolAnnotation.TextColor.HasValue) { symbolOptions.WithTextColor(symbolAnnotation.TextColor.Value.ToRGBAString()); } if (!string.IsNullOrWhiteSpace(symbolAnnotation.TextField)) { symbolOptions.WithTextField(symbolAnnotation.TextField); } if (symbolAnnotation.TextFont?.Length > 0) { symbolOptions.WithTextFont(symbolAnnotation.TextFont); } if (symbolAnnotation.TextHaloBlur.HasValue) { symbolOptions.WithTextHaloBlur(new Float(symbolAnnotation.TextHaloBlur.Value)); } if (symbolAnnotation.TextHaloColor.HasValue) { symbolOptions.WithTextHaloColor(symbolAnnotation.TextHaloColor.Value.ToRGBAString()); } if (symbolAnnotation.TextHaloWidth.HasValue) { symbolOptions.WithTextHaloWidth(new Float(symbolAnnotation.TextHaloWidth.Value)); } if (!string.IsNullOrWhiteSpace(symbolAnnotation.TextJustify)) { symbolOptions.WithTextJustify(symbolAnnotation.TextJustify); } if (symbolAnnotation.TextLetterSpacing.HasValue) { symbolOptions.WithTextLetterSpacing(new Float(symbolAnnotation.TextLetterSpacing.Value)); } if (symbolAnnotation.TextMaxWidth.HasValue) { symbolOptions.WithTextMaxWidth(new Float(symbolAnnotation.TextMaxWidth.Value)); } if (symbolAnnotation.TextOffset?.Length > 0) { symbolOptions.WithTextOffset(symbolAnnotation.TextOffset.Select(x => new Float(x)).ToArray()); } if (symbolAnnotation.TextOpacity.HasValue) { symbolOptions.WithTextOpacity(new Float(symbolAnnotation.TextOpacity.Value)); } if (symbolAnnotation.TextRadialOffset.HasValue) { symbolOptions.WithTextRadialOffset(new Float(symbolAnnotation.TextRadialOffset.Value)); } if (symbolAnnotation.TextRotate.HasValue) { symbolOptions.WithTextRotate(new Float(symbolAnnotation.TextRotate.Value)); } if (symbolAnnotation.TextSize.HasValue) { symbolOptions.WithTextSize(new Float(symbolAnnotation.TextSize.Value)); } if (!string.IsNullOrWhiteSpace(symbolAnnotation.TextTransform)) { symbolOptions.WithTextTransform(symbolAnnotation.TextTransform); } return(symbolOptions); }
public static void Update(this Symbol symbol, SymbolAnnotation symbolAnnotation) { if (!string.IsNullOrWhiteSpace(symbolAnnotation.IconAnchor)) { symbol.IconImage = symbolAnnotation.IconAnchor; } if (symbolAnnotation.IconColor.HasValue) { symbol.IconColor = symbolAnnotation.IconColor.Value.ToRGBAString(); } if (symbolAnnotation.IconHaloBlur.HasValue) { symbol.IconHaloBlur = new Float(symbolAnnotation.IconHaloBlur.Value); } if (symbolAnnotation.IconHaloColor.HasValue) { symbol.IconHaloColor = symbolAnnotation.IconHaloColor.Value.ToRGBAString(); } if (symbolAnnotation.IconHaloWidth.HasValue) { symbol.IconHaloWidth = new Float(symbolAnnotation.IconHaloWidth.Value); } if (symbolAnnotation.IconImage != null) { symbol.IconImage = (symbolAnnotation.IconImage.Id); } if (symbolAnnotation.IconOffset?.Length > 0) { symbol.IconOffset = new Android.Graphics.PointF( symbolAnnotation.IconOffset[0], symbolAnnotation.IconOffset[1]); } if (symbolAnnotation.IconOpacity.HasValue) { symbol.IconOpacity = (new Float(symbolAnnotation.IconOpacity.Value)); } if (symbolAnnotation.IconRotate.HasValue) { symbol.IconRotate = (new Float(symbolAnnotation.IconRotate.Value)); } if (symbolAnnotation.IconSize.HasValue) { symbol.IconSize = (new Float(symbolAnnotation.IconSize.Value)); } if (symbolAnnotation.IsDraggable.HasValue) { symbol.Draggable = (symbolAnnotation.IsDraggable.Value); } if (symbolAnnotation.SymbolSortKey.HasValue) { symbol.SymbolSortKey = (new Float(symbolAnnotation.SymbolSortKey.Value)); } if (!string.IsNullOrWhiteSpace(symbolAnnotation.TextAnchor)) { symbol.TextAnchor = (symbolAnnotation.TextAnchor); } if (symbolAnnotation.TextColor.HasValue) { symbol.TextColor = (symbolAnnotation.TextColor.Value.ToRGBAString()); } if (!string.IsNullOrWhiteSpace(symbolAnnotation.TextField)) { symbol.TextField = (symbolAnnotation.TextField); } if (symbolAnnotation.TextFont?.Length > 0) { symbol.SetTextFont(symbolAnnotation.TextFont); } if (symbolAnnotation.TextHaloBlur.HasValue) { symbol.TextHaloBlur = (new Float(symbolAnnotation.TextHaloBlur.Value)); } if (symbolAnnotation.TextHaloColor.HasValue) { symbol.TextHaloColor = (symbolAnnotation.TextHaloColor.Value.ToRGBAString()); } if (symbolAnnotation.TextHaloWidth.HasValue) { symbol.TextHaloWidth = (new Float(symbolAnnotation.TextHaloWidth.Value)); } if (!string.IsNullOrWhiteSpace(symbolAnnotation.TextJustify)) { symbol.TextJustify = (symbolAnnotation.TextJustify); } if (symbolAnnotation.TextLetterSpacing.HasValue) { symbol.TextLetterSpacing = (new Float(symbolAnnotation.TextLetterSpacing.Value)); } if (symbolAnnotation.TextMaxWidth.HasValue) { symbol.TextMaxWidth = (new Float(symbolAnnotation.TextMaxWidth.Value)); } if (symbolAnnotation.TextOffset?.Length > 0) { symbol.TextOffset = new Android.Graphics.PointF( symbolAnnotation.TextOffset[0], symbolAnnotation.TextOffset[1]); } if (symbolAnnotation.TextOpacity.HasValue) { symbol.TextOpacity = (new Float(symbolAnnotation.TextOpacity.Value)); } if (symbolAnnotation.TextRadialOffset.HasValue) { symbol.TextRadialOffset = (new Float(symbolAnnotation.TextRadialOffset.Value)); } if (symbolAnnotation.TextRotate.HasValue) { symbol.TextRotate = (new Float(symbolAnnotation.TextRotate.Value)); } if (symbolAnnotation.TextSize.HasValue) { symbol.TextSize = new Float(symbolAnnotation.TextSize.Value); } if (!string.IsNullOrWhiteSpace(symbolAnnotation.TextTransform)) { symbol.TextTransform = (symbolAnnotation.TextTransform); } }