public void Constructor_SetsNameWithSignature(ReferenceKind type) { var reference = type == ReferenceKind.TypeLibrary ? LibraryReference : ProjectReference; var viewModel = new CodeExplorerReferenceViewModel(null, reference); Assert.IsFalse(string.IsNullOrEmpty(viewModel.NameWithSignature)); }
public Reference(MethodInfo p, int c) { kind = ReferenceKind.methodInfo_; ptr = (object)p; count = c; del = null; }
public Reference(Delegate d, int c) { kind = ReferenceKind.delegate_; del = d; count = c; ptr = null; }
public Reference(object p, int c) { kind = ReferenceKind.object_; ptr = p; count = c; del = null; }
public void Constructor_SetsIsExpandedFalse(ReferenceKind type) { var reference = type == ReferenceKind.TypeLibrary ? LibraryReference : ProjectReference; var viewModel = new CodeExplorerReferenceViewModel(null, reference); Assert.IsFalse(viewModel.IsExpanded); }
public void Constructor_SetsName(ReferenceKind type) { var reference = type == ReferenceKind.TypeLibrary ? LibraryReference : ProjectReference; var viewModel = new CodeExplorerReferenceViewModel(null, reference); Assert.AreEqual(reference.Name, viewModel.Name); }
public void Constructor_ToolTip_IsDescription(ReferenceKind type) { var reference = type == ReferenceKind.TypeLibrary ? LibraryReference : ProjectReference; var viewModel = new CodeExplorerReferenceViewModel(null, reference); Assert.AreEqual(reference.Description, viewModel.ToolTip); }
public int CollectReference(int sourceSymbolId, int referenceSymbolId, ReferenceKind referenceKind) { if (sourceSymbolId <= 0 || referenceSymbolId <= 0) { throw new ArgumentException("A symbol-id must be greater than zero"); } return(sourcetraildb.recordReference(sourceSymbolId, referenceSymbolId, referenceKind)); }
public void ErrorStateCanNotBeSet(ReferenceKind type) { var folder = new CodeExplorerReferenceFolderViewModel(null, null, Enumerable.Empty <ReferenceModel>().ToList(), type) { IsErrorState = true }; Assert.IsFalse(folder.IsErrorState); }
public void UnusedReferenceIsDimmed(ReferenceKind type) { var reference = type == ReferenceKind.TypeLibrary ? LibraryReference : ProjectReference; var viewModel = new CodeExplorerReferenceViewModel(null, reference); reference.IsUsed = false; Assert.IsTrue(viewModel.IsDimmed); }
public ReferenceEndpoint(ReferenceKind referenceKind, INamedTypeSymbol symbol) { if (symbol == null) { throw new ArgumentNullException("symbol"); } ReferenceKind = referenceKind; Symbol = symbol; }
public void ErrorStateCanNotBeSet(ReferenceKind type) { var reference = type == ReferenceKind.TypeLibrary ? LibraryReference : ProjectReference; var viewModel = new CodeExplorerReferenceViewModel(null, reference) { IsErrorState = true }; Assert.IsFalse(viewModel.IsErrorState); }
internal ReferenceArgs(Parser parser, ReferenceKind kind, string mimeType = null) { if (parser == null) { throw new ArgumentNullException("parser"); } Parser = parser; Kind = kind; MimeType = !string.IsNullOrEmpty(mimeType) ? mimeType : null; }
public void ReferenceLockedStateMatchesIsBuiltIn(ReferenceKind type, bool builtIn) { var reference = type == ReferenceKind.TypeLibrary ? LibraryReference : ProjectReference; reference.IsBuiltIn = builtIn; var viewModel = new CodeExplorerReferenceViewModel(null, reference); Assert.AreEqual(builtIn, viewModel.Locked); }
public CodeExplorerReferenceFolderViewModel( ICodeExplorerNode parent, DeclarationFinder finder, List <ReferenceModel> references, ReferenceKind type) : base(parent, parent?.Declaration) { _finder = finder; ReferenceKind = type; Synchronize(Declaration, references); }
public ReferenceModel(ReferenceInfo info, ReferenceKind type, bool recent = false, bool pinned = false) : this() { Guid = info.Guid; Name = info.Name; Description = Name; FullPath = info.FullPath; Major = info.Major; Minor = info.Minor; IsRecent = recent; IsPinned = pinned; Type = type; }
public void FilteredIsFalseForAnyCharacter(ReferenceKind type) { const string testCharacters = "abcdefghijklmnopqrstuwxyz"; var folder = new CodeExplorerReferenceFolderViewModel(null, null, Enumerable.Empty <ReferenceModel>().ToList(), type); foreach (var character in testCharacters.ToCharArray().Select(letter => letter.ToString())) { folder.Filter = character; Assert.IsFalse(folder.Filtered); } }
/// <summary> /// Initializes a new instance of the <see cref="ReferenceSearchValue"/> class. /// </summary> /// <param name="referenceKind">The kind of reference.</param> /// <param name="baseUri">The base URI of the resource.</param> /// <param name="resourceType">The resource type.</param> /// <param name="resourceId">The resource id.</param> public ReferenceSearchValue(ReferenceKind referenceKind, Uri baseUri, ResourceType?resourceType, string resourceId) { if (baseUri != null) { EnsureArg.IsNotNull(resourceType, nameof(resourceType)); } EnsureArg.IsNotNullOrWhiteSpace(resourceId, nameof(resourceId)); Kind = referenceKind; BaseUri = baseUri; ResourceType = resourceType; ResourceId = resourceId; }
public void Synchronize_RemovesReferenceFromList(ReferenceKind type) { var references = type == ReferenceKind.TypeLibrary ? AddRemoveReferencesSetup.DummyReferencesList : AddRemoveReferencesSetup.DummyProjectsList; var synching = references.First(); var viewModel = new CodeExplorerReferenceViewModel(null, synching); viewModel.Synchronize(null, references); Assert.IsFalse(references.Contains(synching)); }
public static FunctionPointerType FromSignature(MethodSignature <IType> signature, MetadataModule module) { IType returnType = signature.ReturnType; bool returnIsRefReadOnly = false; if (returnType is ModifiedType modReturn && modReturn.Modifier.IsKnownType(KnownAttribute.In)) { returnType = modReturn.ElementType; returnIsRefReadOnly = true; } var parameterTypes = ImmutableArray.CreateBuilder <IType>(signature.ParameterTypes.Length); var parameterReferenceKinds = ImmutableArray.CreateBuilder <ReferenceKind>(signature.ParameterTypes.Length); foreach (var p in signature.ParameterTypes) { IType paramType = p; ReferenceKind kind = ReferenceKind.None; if (p is ModifiedType modreq) { if (modreq.Modifier.IsKnownType(KnownAttribute.In)) { kind = ReferenceKind.In; paramType = modreq.ElementType; } else if (modreq.Modifier.IsKnownType(KnownAttribute.Out)) { kind = ReferenceKind.Out; paramType = modreq.ElementType; } } if (paramType.Kind == TypeKind.ByReference) { if (kind == ReferenceKind.None) { kind = ReferenceKind.Ref; } } else { kind = ReferenceKind.None; } parameterTypes.Add(paramType); parameterReferenceKinds.Add(kind); } return(new FunctionPointerType( module, signature.Header.CallingConvention, returnType, returnIsRefReadOnly, parameterTypes.MoveToImmutable(), parameterReferenceKinds.MoveToImmutable())); }
public void Synchronize_Unmatched_SetsReferenceNull(ReferenceKind type) { var references = type == ReferenceKind.TypeLibrary ? AddRemoveReferencesSetup.DummyReferencesList : AddRemoveReferencesSetup.DummyProjectsList; var removing = references.First(); var viewModel = new CodeExplorerReferenceViewModel(null, removing); references.Remove(removing); viewModel.Synchronize(null, references); Assert.IsNull(viewModel.Reference); }
public void FilteredIsTrueForCharactersNotInName(ReferenceKind type) { const string testCharacters = "abcdefghijklmnopqrstuwxyz"; var reference = type == ReferenceKind.TypeLibrary ? LibraryReference : ProjectReference; var viewModel = new CodeExplorerReferenceViewModel(null, reference); var name = viewModel.Name; var nonMatching = testCharacters.ToCharArray().Except(name.ToLowerInvariant().ToCharArray()); foreach (var character in nonMatching.Select(letter => letter.ToString())) { viewModel.Filter = character; Assert.IsTrue(viewModel.Filtered); } }
public static ReferenceSpec GetEmitter(MemberSpec ms, int idx, ReferenceKind k, bool reference = false) { ReferenceSpec Emitter = null; if (reference) { Emitter = new ReferenceEmitter(ms, 4, ReferenceKind.Parameter); Emitter.BaseEmitter = GetEmitter(new ParameterSpec(ms.Name, (ms as ParameterSpec).MethodHost, ms.Signature.Location, idx), idx, ReferenceKind.Parameter); } else { Emitter = new WordEmitter(ms, idx, k); } return(Emitter); }
public Reference(string separatedLine, string sourceLine) { var parts = separatedLine.Split(';'); FromAssemblyId = string.Intern(parts[0]); Url = parts[1]; FromLocalPath = parts[2]; ReferenceLineNumber = int.Parse(parts[3]); ReferenceColumnStart = int.Parse(parts[4]); ReferenceColumnEnd = int.Parse(parts[5]); if (parts.Length >= 7) { Kind = (ReferenceKind)int.Parse(parts[6]); } ReferenceLineText = sourceLine; ToSymbolName = ReferenceLineText.Substring(ReferenceColumnStart, ReferenceColumnEnd - ReferenceColumnStart); }
public void FilteredIsFalseForSubsetsOfName(ReferenceKind type) { var reference = type == ReferenceKind.TypeLibrary ? LibraryReference : ProjectReference; var viewModel = new CodeExplorerReferenceViewModel(null, reference); var name = viewModel.Name; for (var characters = 1; characters <= name.Length; characters++) { viewModel.Filter = name.Substring(0, characters); Assert.IsFalse(viewModel.Filtered); } for (var position = name.Length - 2; position > 0; position--) { viewModel.Filter = name.Substring(position); Assert.IsFalse(viewModel.Filtered); } }
private ReferenceSymbol GetReferenceSymbol(ISymbol symbol, ReferenceKind referenceKind, string id = null) { // Use unspecialized generic // TODO: Consider adding reference symbol for specialized generic as well so one can find all references // to List<string>.Add rather than just List<T>.Add symbol = symbol.OriginalDefinition; var boundSymbol = new ReferenceSymbol() { ProjectId = symbol.ContainingAssembly.Name, Id = CreateSymbolId(id ?? GetDocumentationCommentId(symbol)), Kind = GetSymbolKind(symbol), ReferenceKind = referenceKind.GetString(), IsImplicitlyDeclared = symbol.IsImplicitlyDeclared }; if (!string.IsNullOrEmpty(symbol.Name)) { DefinitionSymbol definition; if (!context.ReferenceDefinitionMap.TryGetValue(boundSymbol.Id.Value, out definition)) { var createdDefinition = GetDefinitionSymbol(symbol); definition = context.ReferenceDefinitionMap.GetOrAdd(boundSymbol.Id.Value, createdDefinition); if (createdDefinition == definition) { if (symbol.Kind != SymbolKind.Namespace && symbol.ContainingNamespace != null && !symbol.ContainingNamespace.IsGlobalNamespace) { var namespaceSymbol = GetReferenceSymbol(symbol.ContainingNamespace, ReferenceKind.Reference); var extData = context.GetReferenceNamespaceData(namespaceSymbol.Id.Value); definition.ExtData = extData; } } } if (referenceKind != ReferenceKind.Definition) { definition.IncrementReferenceCount(); } } return(boundSymbol); }
/// <summary> /// Initializes a new instance of the <see cref="Reference{TName,TSymbol}"/> class. /// </summary> /// <param name="symbol">The symbol being referenced; or <see langword="null"/>.</param> /// <param name="document">The document with the reference.</param> /// <param name="name">The range of the name of the reference.</param> /// <param name="range">The range of the whole reference.</param> /// <param name="kind">The kind of reference.</param> public Reference([CanBeNull] Symbol <TName, TSymbol> symbol, Uri document, Range name, Range range, ReferenceKind kind) { #region Contract if (document == null) { throw new ArgumentNullException(nameof(document)); } if (Enum.IsDefined(typeof(ReferenceKind), kind)) { throw new ArgumentException("Value is not a member of the enum.", nameof(kind)); } #endregion this.Symbol = symbol; this.Document = document; this.Name = name; this.Range = range; this.Kind = kind; }
public DefaultParameter(IType type, string name, IParameterizedMember owner = null, IReadOnlyList <IAttribute> attributes = null, ReferenceKind referenceKind = ReferenceKind.None, bool isParams = false, bool isOptional = false, object defaultValue = null) { if (type == null) { throw new ArgumentNullException(nameof(type)); } if (name == null) { throw new ArgumentNullException(nameof(name)); } this.type = type; this.name = name; this.owner = owner; this.attributes = attributes ?? EmptyList <IAttribute> .Instance; this.referenceKind = referenceKind; this.isParams = isParams; this.isOptional = isOptional; this.defaultValue = defaultValue; }
static ReferenceKind GetKind(HtmlNode element, ReferenceKind defaultKind) { var relationshipAttribute = element.Attributes["rel"]; if (relationshipAttribute == null || string.IsNullOrEmpty(relationshipAttribute.Value)) { return(defaultKind); } var relationships = Helper.SplitSpaceSeparatedTokens(relationshipAttribute.Value); if (relationships.Any(relationship => _externalResourceRelationships.Any(type => string.Equals(relationship, type, StringComparison.OrdinalIgnoreCase)))) { return(ReferenceKind.ExternalResource); } if (relationships.Any(relationship => _skipRelationships.Any(type => string.Equals(relationship, type, StringComparison.OrdinalIgnoreCase)))) { return(ReferenceKind.Skip); } return(defaultKind); }
public VirtualParameter(IType type, string name, IParameterizedMember owner = null, IEnumerable <IAttribute> attributes = null, ReferenceKind referenceKind = ReferenceKind.None, bool isRef = false, bool isOut = false, bool isIn = false, bool isParams = false, bool isOptional = false, object defaultValue = null) { if (type == null) { throw new ArgumentNullException("type"); } if (name == null) { throw new ArgumentNullException("name"); } this.type = type; this.name = name; this.owner = owner; this.Attributes = attributes?.ToList() ?? new List <IAttribute>(); this.ReferenceKind = referenceKind; this.isRef = isRef; this.isOut = isOut; this.isIn = isIn; this.isParams = isParams; this.isOptional = isOptional; this.defaultValue = defaultValue; }
public void AddReference( string documentDestinationPath, SourceText referenceText, string destinationAssemblyName, ISymbol symbol, string symbolId, int startPosition, int endPosition, ReferenceKind kind) { string referenceString = referenceText.ToString(TextSpan.FromBounds(startPosition, endPosition)); if (symbol is INamedTypeSymbol && (referenceString == "this" || referenceString == "base")) { // Don't count "this" or "base" expressions that bind to this type as references return; } var line = referenceText.Lines.GetLineFromPosition(startPosition); int start = referenceText.Lines.GetLinePosition(startPosition).Character; int end = start + endPosition - startPosition; int lineNumber = line.LineNumber + 1; string lineText = line.ToString(); AddReference( documentDestinationPath, lineText, start, referenceString.Length, lineNumber, AssemblyName, destinationAssemblyName, symbol, symbolId, kind); }
public void AddReference( string documentDestinationPath, string lineText, int referenceStartOnLine, int referenceLength, int lineNumber, string fromAssemblyName, string toAssemblyName, ISymbol symbol, string symbolId, ReferenceKind kind) { string localPath = Paths.MakeRelativeToFolder( documentDestinationPath, Path.Combine(SolutionGenerator.SolutionDestinationFolder, fromAssemblyName)); localPath = Path.ChangeExtension(localPath, null); int referenceEndOnLine = referenceStartOnLine + referenceLength; lineText = Markup.HtmlEscape(lineText, ref referenceStartOnLine, ref referenceEndOnLine); string symbolName = GetSymbolName(symbol, symbolId); var reference = new Reference() { ToAssemblyId = toAssemblyName, ToSymbolId = symbolId, ToSymbolName = symbolName, FromAssemblyId = fromAssemblyName, FromLocalPath = localPath, ReferenceLineText = lineText, ReferenceLineNumber = lineNumber, ReferenceColumnStart = referenceStartOnLine, ReferenceColumnEnd = referenceEndOnLine, Kind = kind }; if (referenceStartOnLine < 0 || referenceStartOnLine >= referenceEndOnLine || referenceEndOnLine > lineText.Length) { Log.Exception( string.Format("AddReference: start = {0}, end = {1}, lineText = {2}, documentDestinationPath = {3}", referenceStartOnLine, referenceEndOnLine, lineText, documentDestinationPath)); } string linkRelativePath = GetLinkRelativePath(reference); reference.Url = linkRelativePath; Dictionary<string, List<Reference>> referencesToAssembly = GetReferencesToAssembly(reference.ToAssemblyId); List<Reference> referencesToSymbol = GetReferencesToSymbol(reference, referencesToAssembly); lock (referencesToSymbol) { referencesToSymbol.Add(reference); } }
private HtmlElementInfo ProcessReference(Classification.Range range, ISymbol symbol, ReferenceKind kind, bool isLargeFile = false) { ClassifiedSpan classifiedSpan = range.ClassifiedSpan; var methodSymbol = symbol as IMethodSymbol; if (methodSymbol != null && methodSymbol.ReducedFrom != null) { symbol = methodSymbol.ReducedFrom; } HtmlElementInfo result = null; if (symbol.IsImplicitlyDeclared) { if (methodSymbol != null && methodSymbol.MethodKind == MethodKind.Constructor && symbol.ContainingSymbol != null) { return ProcessReference(range, symbol.ContainingSymbol, ReferenceKind.Instantiation); } } if (symbol.Kind == SymbolKind.Local || symbol.Kind == SymbolKind.Parameter || symbol.Kind == SymbolKind.TypeParameter) { if (isLargeFile) { return null; } return HighlightReference(symbol); } if (methodSymbol != null && methodSymbol.MethodKind == MethodKind.Constructor && methodSymbol.ContainingType != null) { ProcessReference(range, methodSymbol.ContainingType, ReferenceKind.Instantiation); } if ((symbol.Kind == SymbolKind.Event || symbol.Kind == SymbolKind.Field || symbol.Kind == SymbolKind.Method || symbol.Kind == SymbolKind.NamedType || symbol.Kind == SymbolKind.Property) && symbol.Locations.Length >= 1) { var typeSymbol = symbol as ITypeSymbol; string symbolId = SymbolIdService.GetId(symbol); var location = symbol.Locations[0]; string destinationAssemblyName = null; if (location.IsInSource) { result = GenerateHyperlink(symbol, symbolId, location.SourceTree, out destinationAssemblyName); } else if (location.IsInMetadata && location.MetadataModule != null) { var metadataModule = location.MetadataModule; result = GenerateHyperlink(symbolId, symbol, metadataModule, isLargeFile, out destinationAssemblyName); } if (result == null) { return result; } string target; if (result.Attributes == null || !result.Attributes.TryGetValue("href", out target) || !target.Contains("@")) { // only register a reference to the symbol if it's not a symbol from an external assembly. // if this links to a symbol in a different index, link target contain @. projectGenerator.AddReference( this.documentDestinationFilePath, Text, destinationAssemblyName, symbol, symbolId, classifiedSpan.TextSpan.Start, classifiedSpan.TextSpan.End, kind); } } // don't make this and var into hyperlinks in large files to save space if (isLargeFile && (range.Text == "this" || range.Text == "var")) { result = null; } return result; }