// CompletionDataList result = new ProjectDomCompletionDataList ();
// // "var o = new " needs special treatment.
// if (returnType == null && returnTypeUnresolved != null && returnTypeUnresolved.FullName == "var")
// returnType = returnTypeUnresolved = DomReturnType.Object;
//
// // ExpressionContext.TypeExpressionContext tce = context as ExpressionContext.TypeExpressionContext;
//
// CompletionDataCollector col = new CompletionDataCollector (this, dom, result, Document.CompilationUnit, callingType, location);
// IType type = null;
// if (returnType != null)
// type = dom.GetType (returnType);
// if (type == null)
// type = dom.SearchType (Document.CompilationUnit, callingType, location, returnTypeUnresolved);
//
// // special handling for nullable types: Bug 674516 - new completion for nullables should not include "Nullable"
// if (type is InstantiatedType && ((InstantiatedType)type).UninstantiatedType.FullName == "System.Nullable" && ((InstantiatedType)type).GenericParameters.Count == 1) {
// var genericParameter = ((InstantiatedType)type).GenericParameters [0];
// returnType = returnTypeUnresolved = Document.CompilationUnit.ShortenTypeName (genericParameter, location);
// type = dom.SearchType (Document.CompilationUnit, callingType, location, genericParameter);
// }
//
// if (type == null || !(type.IsAbstract || type.ClassType == ClassType.Interface)) {
// if (type == null || type.ConstructorCount == 0 || type.Methods.Any (c => c.IsConstructor && c.IsAccessibleFrom (dom, callingType, type, callingType != null && dom.GetInheritanceTree (callingType).Any (x => x.FullName == type.FullName)))) {
// if (returnTypeUnresolved != null) {
// col.FullyQualify = true;
// CompletionData unresovedCompletionData = col.Add (returnTypeUnresolved);
// col.FullyQualify = false;
// // don't set default completion string for arrays, since it interferes with:
// // string[] arr = new string[] vs new { "a"}
// if (returnTypeUnresolved.ArrayDimensions == 0)
// result.DefaultCompletionString = StripGenerics (unresovedCompletionData.CompletionText);
// } else {
// CompletionData unresovedCompletionData = col.Add (returnType);
// if (returnType.ArrayDimensions == 0)
// result.DefaultCompletionString = StripGenerics (unresovedCompletionData.CompletionText);
// }
// }
// }
//
// // if (tce != null && tce.Type != null) {
// // result.DefaultCompletionString = StripGenerics (col.AddCompletionData (result, tce.Type).CompletionString);
// // }
// // else {
// // }
// if (type == null)
// return result;
// HashSet<string > usedNamespaces = new HashSet<string> (GetUsedNamespaces ());
// if (type.FullName == DomReturnType.Object.FullName)
// AddPrimitiveTypes (col);
//
// foreach (IType curType in dom.GetSubclasses (type)) {
// if (context != null && context.FilterEntry (curType))
// continue;
// if ((curType.TypeModifier & TypeModifier.HasOnlyHiddenConstructors) == TypeModifier.HasOnlyHiddenConstructors)
// continue;
// if (usedNamespaces.Contains (curType.Namespace)) {
// if (curType.ConstructorCount > 0) {
// if (!(curType.Methods.Any (c => c.IsConstructor && c.IsAccessibleFrom (dom, curType, callingType, callingType != null && dom.GetInheritanceTree (callingType).Any (x => x.FullName == curType.FullName)))))
// continue;
// }
// col.Add (curType);
// } else {
// string nsName = curType.Namespace;
// int idx = nsName.IndexOf ('.');
// if (idx >= 0)
// nsName = nsName.Substring (0, idx);
// col.Add (new Namespace (nsName));
// }
// }
//
// // add aliases
// if (returnType != null) {
// foreach (IUsing u in Document.CompilationUnit.Usings) {
// foreach (KeyValuePair<string, IReturnType> alias in u.Aliases) {
// if (alias.Value.ToInvariantString () == returnType.ToInvariantString ())
// result.Add (alias.Key, "md-class");
// }
// }
// }
//
// return result;
// }
// IEnumerable<ICompletionData> GetDefineCompletionData ()
// {
// if (Document.Project == null)
// yield break;
//
// var symbols = new Dictionary<string, string> ();
// var cp = new ProjectDomCompletionDataList ();
// foreach (DotNetProjectConfiguration conf in Document.Project.Configurations) {
// var cparams = conf.CompilationParameters as CSharpCompilerParameters;
// if (cparams != null) {
// string[] syms = cparams.DefineSymbols.Split (';');
// foreach (string s in syms) {
// string ss = s.Trim ();
// if (ss.Length > 0 && !symbols.ContainsKey (ss)) {
// symbols [ss] = ss;
// yield return factory.CreateLiteralCompletionData (ss);
// }
// }
// }
// }
// }
public override ParameterDataProvider HandleParameterCompletion(CodeCompletionContext completionContext, char completionChar)
{
if (!EnableCodeCompletion)
{
return(null);
}
if (Unit == null || CSharpUnresolvedFile == null)
{
return(null);
}
try {
var engine = new CSharpParameterCompletionEngine(
TextEditorData.Document,
typeSystemSegmentTree,
this,
Document.GetProjectContext(),
CSharpUnresolvedFile.GetTypeResolveContext(Document.Compilation, document.Editor.Caret.Location) as CSharpTypeResolveContext
);
return(engine.GetParameterDataProvider(completionContext.TriggerOffset, completionChar) as ParameterDataProvider);
} catch (Exception e) {
LoggingService.LogError("Unexpected parameter completion exception." + Environment.NewLine +
"FileName: " + Document.FileName + Environment.NewLine +
"Position: line=" + completionContext.TriggerLine + " col=" + completionContext.TriggerLineOffset + Environment.NewLine +
"Line text: " + Document.Editor.GetLineText(completionContext.TriggerLine),
e);
return(null);
} finally {
// if (timer != null)
// timer.Dispose ();
}
}
public CSharpFile(CSharpProject project, string fileName)
{
this.Project = project;
this.FileName = fileName;
CSharpParser p = new CSharpParser(project.CompilerSettings);
// using (var stream = File.OpenRead(fileName)) {
// this.CompilationUnit = p.Parse(stream, fileName);
// }
// Keep the original text around; we might use it for a refactoring later
this.OriginalText = File.ReadAllText(fileName);
this.SyntaxTree = p.Parse(this.OriginalText, fileName);
this.SyntaxTree.Freeze(); // the various tests shouldn't modify the AST shared by all tests
if (p.HasErrors)
{
Console.WriteLine("Error parsing " + fileName + ":");
foreach (var error in p.ErrorsAndWarnings)
{
Console.WriteLine(" " + error.Region + " " + error.Message);
}
}
this.UnresolvedTypeSystemForFile = this.SyntaxTree.ToTypeSystem();
}
public static ResolveResult Resolve(Lazy <ICompilation> compilation, CSharpUnresolvedFile unresolvedFile, SyntaxTree syntaxTree, TextLocation location,
CancellationToken cancellationToken = default(CancellationToken))
{
AstNode node;
return(Resolve(compilation, unresolvedFile, syntaxTree, location, out node, cancellationToken));
}
// Token: 0x06000012 RID: 18 RVA: 0x0000243C File Offset: 0x0000063C
private ResolveResult GetLanguageItem(ProjectDocument doc, string expression, Client.SourceLocation location)
{
ParsedDocument parsedDocument = doc.ParsedDocument;
if (parsedDocument == null)
{
return(null);
}
SyntaxTree ast = parsedDocument.GetAst <SyntaxTree>();
CSharpUnresolvedFile csharpUnresolvedFile = parsedDocument.ParsedFile as CSharpUnresolvedFile;
if (ast == null || csharpUnresolvedFile == null)
{
return(null);
}
AstNode nodeAt = ast.GetNodeAt(location.Line, location.Column, null);
if (nodeAt == null)
{
return(null);
}
CSharpTypeResolveContext typeResolveContext = csharpUnresolvedFile.GetTypeResolveContext(doc.Compilation, new TextLocation(location.Line, location.Column));
CSharpResolver resolver = new CSharpResolver(typeResolveContext);
CSharpAstResolver csharpAstResolver = new CSharpAstResolver(resolver, ast, csharpUnresolvedFile);
csharpAstResolver.ApplyNavigator(new NodeListResolveVisitorNavigator(new AstNode[]
{
nodeAt
}), CancellationToken.None);
CSharpResolver resolverStateBefore = csharpAstResolver.GetResolverStateBefore(nodeAt, CancellationToken.None);
return(resolverStateBefore.LookupSimpleNameOrTypeName(expression, new List <IType>(), NameLookupMode.Expression));
}
public static ICompilation CreateCompilationWithoutCorlib(params IUnresolvedTypeDefinition[] unresolvedTypeDefinitions)
{
var unresolvedFile = new CSharpUnresolvedFile();
foreach (var typeDef in unresolvedTypeDefinitions)
unresolvedFile.TopLevelTypeDefinitions.Add(typeDef);
return CreateCompilation(unresolvedFile);
}
public MethodParameterDataProvider(int startOffset, CSharpCompletionTextEditorExtension ext, IEnumerable <IMethod> m) : base(ext, startOffset)
{
compilation = ext.UnresolvedFileCompilation;
file = ext.CSharpUnresolvedFile;
HashSet <string> alreadyAdded = new HashSet <string> ();
foreach (var method in m)
{
if (method.IsConstructor)
{
continue;
}
if (!method.IsBrowsable())
{
continue;
}
string str = ambience.GetString(method, OutputFlags.IncludeParameters | OutputFlags.GeneralizeGenerics | OutputFlags.IncludeGenerics);
if (alreadyAdded.Contains(str))
{
continue;
}
alreadyAdded.Add(str);
methods.Add(method);
}
methods.Sort(MethodComparer);
}
private void CompileAndResolve()
{
_unresolvedFile = SyntaxTree.ToTypeSystem();
_projectContent = _projectContent.AddOrUpdateFiles(_unresolvedFile);
_compilation = _projectContent.CreateCompilation();
_resolver = new CSharpAstResolver(_compilation, SyntaxTree, _unresolvedFile);
}
public IndexerParameterDataProvider (int startOffset, CSharpCompletionTextEditorExtension ext, IType type, IEnumerable<IProperty> indexers, AstNode resolvedExpression) : base (ext, startOffset)
{
compilation = ext.UnresolvedFileCompilation;
file = ext.CSharpUnresolvedFile;
// this.resolvedExpression = resolvedExpression;
this.indexers = new List<IProperty> (indexers);
}
void Init(string code)
{
syntaxTree = SyntaxTree.Parse(code, "test.cs");
unresolvedFile = syntaxTree.ToTypeSystem();
compilation = TypeSystemHelper.CreateCompilation(unresolvedFile);
findReferences = new FindReferences();
}
private void Prepare(string source, Action preparer)
{
IProjectContent project = new CSharpProjectContent();
var parser = new CSharpParser();
using (var rdr = new StringReader(source)) {
var pf = new CSharpUnresolvedFile {
FileName = "File.cs"
};
var syntaxTree = parser.Parse(rdr, pf.FileName);
syntaxTree.AcceptVisitor(new TypeSystemConvertVisitor(pf));
project = project.AddOrUpdateFiles(pf);
}
project = project.AddAssemblyReferences(new[] { Files.Mscorlib });
var compilation = project.CreateCompilation();
AllTypes = compilation.MainAssembly.TopLevelTypeDefinitions.SelectMany(SelfAndNested).ToDictionary(t => t.ReflectionName);
var er = new MockErrorReporter(true);
var s = new AttributeStore(compilation, er);
Metadata = new MetadataImporter(er, compilation, s, new CompilerOptions());
preparer();
Metadata.Prepare(compilation.GetAllTypeDefinitions());
Assert.That(er.AllMessages, Is.Empty, "Should not generate errrors");
}
public DelegateDataProvider (int startOffset, CSharpCompletionTextEditorExtension ext, IType delegateType) : base (ext, startOffset)
{
compilation = ext.UnresolvedFileCompilation;
file = ext.CSharpUnresolvedFile;
// this.delegateType = delegateType;
this.delegateMethod = delegateType.GetDelegateInvokeMethod ();
}
public static ResolveResult Resolve(Lazy<ICompilation> compilation, CSharpUnresolvedFile unresolvedFile, SyntaxTree syntaxTree, TextLocation location, out AstNode node,
CancellationToken cancellationToken = default(CancellationToken))
{
node = syntaxTree.GetNodeAt(location);
if (node == null || node is ArrayInitializerExpression)
return null;
if (node.Parent is UsingAliasDeclaration && node.Role == UsingAliasDeclaration.AliasRole) {
var r = new CSharpAstResolver(compilation.Value, syntaxTree, unresolvedFile);
return r.Resolve(((UsingAliasDeclaration)node.Parent).Import, cancellationToken);
}
if (CSharpAstResolver.IsUnresolvableNode(node)) {
if (node is Identifier) {
node = node.Parent;
} else if (node.NodeType == NodeType.Token) {
if (node.Parent is IndexerExpression || node.Parent is ConstructorInitializer) {
// There's no other place where one could hover to see the indexer's tooltip,
// so we need to resolve it when hovering over the '[' or ']'.
// For constructor initializer, the same applies to the 'base'/'this' token.
node = node.Parent;
} else {
return null;
}
} else {
// don't resolve arbitrary nodes - we don't want to show tooltips for everything
return null;
}
} else {
// It's a resolvable node.
// However, we usually don't want to show the tooltip everywhere
// For example, hovering with the mouse over an empty line between two methods causes
// node==TypeDeclaration, but we don't want to show any tooltip.
if (!node.GetChildByRole(Roles.Identifier).IsNull) {
// We'll suppress the tooltip for resolvable nodes if there is an identifier that
// could be hovered over instead:
return null;
}
}
if (node == null)
return null;
if (node.Parent is ObjectCreateExpression && node.Role == Roles.Type) {
node = node.Parent;
}
InvocationExpression parentInvocation = null;
if ((node is IdentifierExpression || node is MemberReferenceExpression || node is PointerReferenceExpression) && node.Role != Roles.Argument) {
// we also need to resolve the invocation
parentInvocation = node.Parent as InvocationExpression;
}
// TODO: I think we should provide an overload so that an existing CSharpAstResolver can be reused
CSharpAstResolver resolver = new CSharpAstResolver(compilation.Value, syntaxTree, unresolvedFile);
ResolveResult rr = resolver.Resolve(node, cancellationToken);
if (rr is MethodGroupResolveResult && parentInvocation != null)
return resolver.Resolve(parentInvocation);
else
return rr;
}
public TypeCompletionData(IType type, CSharpCompletionTextEditorExtension ext, Lazy <string> displayText, string icon) : base(null, displayText, icon)
{
this.type = type;
this.ext = ext;
this.file = ext.CSharpUnresolvedFile;
this.compilation = ext.UnresolvedFileCompilation;
}
void Init(string code)
{
syntaxTree = SyntaxTree.Parse(code, "test.cs");
unresolvedFile = syntaxTree.ToTypeSystem();
compilation = TypeSystemHelper.CreateCompilation(unresolvedFile);
findReferences = new FindReferences();
}
protected void Prepare(string source, bool minimizeNames = true, bool expectErrors = false)
{
IProjectContent project = new CSharpProjectContent();
var parser = new CSharpParser();
using (var rdr = new StringReader(source)) {
var pf = new CSharpUnresolvedFile("File.cs");
var syntaxTree = parser.Parse(rdr, pf.FileName);
syntaxTree.AcceptVisitor(new TypeSystemConvertVisitor(pf));
project = project.AddOrUpdateFiles(pf);
}
project = project.AddAssemblyReferences(new[] { Files.Mscorlib });
var compilation = project.CreateCompilation();
_errorReporter = new MockErrorReporter(!expectErrors);
Metadata = new MetadataImporter(_errorReporter, compilation, new CompilerOptions {
MinimizeScript = minimizeNames
});
Metadata.Prepare(compilation.GetAllTypeDefinitions());
AllErrors = _errorReporter.AllMessages.ToList().AsReadOnly();
AllErrorTexts = _errorReporter.AllMessages.Select(m => m.FormattedMessage).ToList().AsReadOnly();
if (expectErrors)
{
Assert.That(AllErrorTexts, Is.Not.Empty, "Compile should have generated errors");
}
else
{
Assert.That(AllErrorTexts, Is.Empty, "Compile should not generate errors");
}
AllTypes = compilation.MainAssembly.TopLevelTypeDefinitions.SelectMany(SelfAndNested).ToDictionary(t => t.ReflectionName);
}
ICompletionDataList InternalHandleCodeCompletion(CodeCompletionContext completionContext, char completionChar, bool ctrlSpace, ref int triggerWordLength)
{
var data = TextEditorData;
if (data.CurrentMode is TextLinkEditMode)
{
if (((TextLinkEditMode)data.CurrentMode).TextLinkMode == TextLinkMode.EditIdentifier)
{
return(null);
}
}
if (Unit == null || CSharpUnresolvedFile == null)
{
return(null);
}
if (typeSystemSegmentTree == null)
{
return(null);
}
var list = new CSharpCompletionDataList();
list.Resolver = CSharpUnresolvedFile != null?CSharpUnresolvedFile.GetResolver(UnresolvedFileCompilation, Document.Editor.Caret.Location) : new CSharpResolver(Compilation);
var ctx = CSharpUnresolvedFile.GetTypeResolveContext(UnresolvedFileCompilation, data.Caret.Location) as CSharpTypeResolveContext;
var engine = new CSharpCompletionEngine(
data.Document,
typeSystemSegmentTree,
new CompletionDataFactory(this, new CSharpResolver(ctx)),
Document.GetProjectContext(),
ctx
);
engine.FormattingPolicy = FormattingPolicy.CreateOptions();
engine.EolMarker = data.EolMarker;
engine.IndentString = data.Options.IndentationString;
try {
foreach (var cd in engine.GetCompletionData(completionContext.TriggerOffset, ctrlSpace))
{
list.Add(cd);
if (cd is IListData)
{
((IListData)cd).List = list;
}
}
} catch (Exception e) {
LoggingService.LogError("Error while getting completion data.", e);
}
list.AutoCompleteEmptyMatch = engine.AutoCompleteEmptyMatch;
list.AutoCompleteEmptyMatchOnCurlyBrace = engine.AutoCompleteEmptyMatchOnCurlyBracket;
list.AutoSelect = engine.AutoSelect;
list.DefaultCompletionString = engine.DefaultCompletionString;
list.CloseOnSquareBrackets = engine.CloseOnSquareBrackets;
if (ctrlSpace)
{
list.AutoCompleteUniqueMatch = true;
}
return(list.Count > 0 ? list : null);
}
public DelegateDataProvider(int startOffset, CSharpCompletionTextEditorExtension ext, IType delegateType) : base(ext, startOffset)
{
compilation = ext.UnresolvedFileCompilation;
file = ext.CSharpUnresolvedFile;
// this.delegateType = delegateType;
this.delegateMethod = delegateType.GetDelegateInvokeMethod();
}
protected void Prepare(string source, bool minimizeNames = true, bool expectErrors = false) {
IProjectContent project = new CSharpProjectContent();
var parser = new CSharpParser();
using (var rdr = new StringReader(source)) {
var pf = new CSharpUnresolvedFile { FileName = "File.cs" };
var syntaxTree = parser.Parse(rdr, pf.FileName);
syntaxTree.AcceptVisitor(new TypeSystemConvertVisitor(pf));
project = project.AddOrUpdateFiles(pf);
}
project = project.AddAssemblyReferences(new[] { Files.Mscorlib });
_errorReporter = new MockErrorReporter(!expectErrors);
var compilation = project.CreateCompilation();
var s = new AttributeStore(compilation, _errorReporter);
RunAutomaticMetadataAttributeAppliers(s, compilation);
s.RunAttributeCode();
Metadata = new MetadataImporter(_errorReporter, compilation, s, new CompilerOptions { MinimizeScript = minimizeNames });
Metadata.Prepare(compilation.GetAllTypeDefinitions());
AllErrors = _errorReporter.AllMessages.ToList().AsReadOnly();
AllErrorTexts = _errorReporter.AllMessages.Select(m => m.FormattedMessage).ToList().AsReadOnly();
if (expectErrors) {
Assert.That(AllErrorTexts, Is.Not.Empty, "Compile should have generated errors");
}
else {
Assert.That(AllErrorTexts, Is.Empty, "Compile should not generate errors");
}
AllTypes = compilation.MainAssembly.TopLevelTypeDefinitions.SelectMany(SelfAndNested).ToDictionary(t => t.ReflectionName);
}
public ICodeContext ResolveContext(ParseInformation parseInfo, TextLocation location, ICompilation compilation, CancellationToken cancellationToken)
{
var csParseInfo = parseInfo as CSharpFullParseInformation;
if (csParseInfo == null)
{
throw new ArgumentException("Parse info does not have SyntaxTree");
}
CSharpUnresolvedFile unresolvedFile = csParseInfo.UnresolvedFile;
var projectContents = compilation.Assemblies.Select(asm => asm.UnresolvedAssembly).OfType <IProjectContent>().ToList();
if (projectContents.All(pc => pc.GetFile(unresolvedFile.FileName) != unresolvedFile))
{
unresolvedFile = null;
}
var syntaxTree = csParseInfo.SyntaxTree;
var node = syntaxTree.GetNodeAt(location);
if (node == null)
{
return(null); // null result is allowed; the parser service will substitute a dummy context
}
var resolver = new CSharpAstResolver(compilation, syntaxTree, unresolvedFile);
return(resolver.GetResolverStateBefore(node));
}
public IndexerParameterDataProvider(int startOffset, CSharpCompletionTextEditorExtension ext, IType type, IEnumerable <IProperty> indexers, AstNode resolvedExpression) : base(ext, startOffset)
{
compilation = ext.UnresolvedFileCompilation;
file = ext.CSharpUnresolvedFile;
// this.resolvedExpression = resolvedExpression;
this.indexers = new List <IProperty> (indexers);
}
public CSharpFile(CSharpProject project, string filePath)
{
_project = project;
_filePath = filePath;
var parser = new CSharpParser(project.CompilerSettings);
if (!(_exists = File.Exists(filePath)))
{
return;
}
using (FileStream stream = File.OpenRead(filePath))
{
_syntaxTree = parser.Parse(stream, filePath);
_unresolvedTypeSystem = _syntaxTree.ToTypeSystem();
}
if (parser.HasErrors)
{
_project.AddToErrorCount(parser.Errors.Count());
}
if (parser.HasWarnings)
{
_project.AddToWarningCount(parser.Warnings.Count());
}
}
public CSharpFile(CSharpProject project, string fileName)
{
Project = project;
FileName = fileName;
CSharpParser p = new CSharpParser(project.CompilerSettings);
// using (var stream = File.OpenRead(fileName)) {
// this.CompilationUnit = p.Parse(stream, fileName);
// }
// Keep the original text around; we might use it for a refactoring later
OriginalText = File.ReadAllText(fileName);
SyntaxTree = p.Parse(OriginalText, fileName);
if (p.HasErrors)
{
Console.WriteLine("Error parsing " + fileName + ":");
foreach (Error error in p.ErrorsAndWarnings)
{
Console.WriteLine(" " + error.Region + " " + error.Message);
}
}
UnresolvedTypeSystemForFile = SyntaxTree.ToTypeSystem();
}
public AstType CreateShortType(ICompilation compilation, CSharpUnresolvedFile parsedFile, TextLocation loc, IType fullType)
{
var csResolver = parsedFile.GetResolver(compilation, loc);
var builder = new ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder(csResolver);
return(builder.ConvertType(fullType));
}
CSharpUnresolvedFile Parse(string program)
{
SyntaxTree syntaxTree = SyntaxTree.Parse(program, "test.cs");
CSharpUnresolvedFile unresolvedFile = syntaxTree.ToTypeSystem();
project = project.AddOrUpdateFiles(unresolvedFile);
compilation = project.CreateCompilation();
return(unresolvedFile);
}
public CSharpFullParseInformation(CSharpUnresolvedFile unresolvedFile, ITextSourceVersion parsedVersion, SyntaxTree compilationUnit)
: base(unresolvedFile, parsedVersion, isFullParseInformation: true)
{
if (unresolvedFile == null)
throw new ArgumentNullException("unresolvedFile");
if (compilationUnit == null)
throw new ArgumentNullException("compilationUnit");
this.syntaxTree = compilationUnit;
}
public DefaultCompletionContextProvider (IDocument document, CSharpUnresolvedFile unresolvedFile)
{
if (document == null)
throw new ArgumentNullException("document");
if (unresolvedFile == null)
throw new ArgumentNullException("unresolvedFile");
this.document = document;
this.unresolvedFile = unresolvedFile;
}
public static ICompilation CreateCompilation(params IUnresolvedTypeDefinition[] unresolvedTypeDefinitions)
{
var unresolvedFile = new CSharpUnresolvedFile("dummy.cs");
foreach (var typeDef in unresolvedTypeDefinitions)
{
unresolvedFile.TopLevelTypeDefinitions.Add(typeDef);
}
return(CreateCompilation(unresolvedFile));
}
void Init(string program)
{
pc = new CSharpProjectContent();
pc = pc.SetAssemblyName("MyAssembly");
unresolvedFile = SyntaxTree.Parse(program, "program.cs").ToTypeSystem();
pc = pc.AddOrUpdateFiles(unresolvedFile);
pc = pc.AddAssemblyReferences(new [] { CecilLoaderTests.Mscorlib });
compilation = pc.CreateCompilation();
}
void Init(string program)
{
pc = new CSharpProjectContent();
pc = pc.SetAssemblyName("MyAssembly");
unresolvedFile = SyntaxTree.Parse(program, "program.cs").ToTypeSystem();
pc = pc.AddOrUpdateFiles(unresolvedFile);
pc = pc.AddAssemblyReferences(new [] { CecilLoaderTests.Mscorlib });
compilation = pc.CreateCompilation();
}
CSharpUnresolvedFile Parse(string program)
{
SyntaxTree syntaxTree = SyntaxTree.Parse(program, "test.cs");
CSharpUnresolvedFile unresolvedFile = syntaxTree.ToTypeSystem();
project = project.AddOrUpdateFiles(unresolvedFile);
compilation = project.CreateCompilation();
lookup = new MemberLookup(null, compilation.MainAssembly);
return(unresolvedFile);
}
// Token: 0x0600001A RID: 26 RVA: 0x00002560 File Offset: 0x00000760
private ParsedDocument Parse(TextReader content, string fileName, ProjectVisualStudio project)
{
CSharpParser csharpParser = new CSharpParser(this.GetCompilerArguments(project));
SyntaxTree syntaxTree = csharpParser.Parse(content, fileName);
syntaxTree.Freeze();
CSharpUnresolvedFile parsedFile = syntaxTree.ToTypeSystem();
return(new ParsedDocument(syntaxTree, parsedFile));
}
public CSharpFile(CSharpProject project, FileName fileName)
{
this.Project = project;
this.FileName = fileName;
this.OriginalText = File.ReadAllText(fileName);
CSharpParser p = new CSharpParser(project.CompilerSettings);
this.SyntaxTree = p.Parse(this.OriginalText, fileName);
this.UnresolvedTypeSystemForFile = SD.ParserService.GetExistingUnresolvedFile(fileName, null, project.IProject) as CSharpUnresolvedFile;
if (this.UnresolvedTypeSystemForFile == null)
throw new InvalidOperationException("LoadSolutionProjectsThread not yet finished?");
}
/// <summary>
/// Creates a new C# AST resolver.
/// Use this overload if you are resolving within a complete C# file.
/// </summary>
/// <param name="compilation">The current compilation.</param>
/// <param name="syntaxTree">The syntax tree to be resolved.</param>
/// <param name="unresolvedFile">
/// Optional: Result of <see cref="SyntaxTree.ToTypeSystem()"/> for the file being resolved.
/// <para>
/// This is used for setting up the context on the resolver. The unresolved file must be registered in the compilation.
/// </para>
/// <para>
/// When a unresolvedFile is specified, the resolver will use the member's StartLocation/EndLocation to identify
/// member declarations in the AST with members in the type system.
/// When no unresolvedFile is specified (<c>null</c> value for this parameter), the resolver will instead compare the
/// member's signature in the AST with the signature in the type system.
/// </para>
/// </param>
public CSharpAstResolver(ICompilation compilation, SyntaxTree syntaxTree, CSharpUnresolvedFile unresolvedFile = null)
{
if (compilation == null)
throw new ArgumentNullException("compilation");
if (syntaxTree == null)
throw new ArgumentNullException("syntaxTree");
this.initialResolverState = new CSharpResolver(compilation);
this.rootNode = syntaxTree;
this.unresolvedFile = unresolvedFile;
this.resolveVisitor = new ResolveVisitor(initialResolverState, unresolvedFile);
}
public override int GetCurrentParameterIndex(int startOffset)
{
var engine = new CSharpParameterCompletionEngine(
TextEditorData.Document,
typeSystemSegmentTree,
this,
Document.GetProjectContext(),
CSharpUnresolvedFile.GetTypeResolveContext(Document.Compilation, document.Editor.Caret.Location) as CSharpTypeResolveContext
);
return(engine.GetCurrentParameterIndex(startOffset, document.Editor.Caret.Offset));
}
public override void SetUp()
{
base.SetUp();
unresolvedFile = new CSharpUnresolvedFile("test.cs");
unresolvedFile.RootUsingScope.Usings.Add(MakeReference("System"));
unresolvedFile.RootUsingScope.Usings.Add(MakeReference("System.Collections.Generic"));
unresolvedFile.RootUsingScope.Usings.Add(MakeReference("System.Linq"));
convertVisitor = new CodeDomConvertVisitor();
convertVisitor.AllowSnippetNodes = false;
convertVisitor.UseFullyQualifiedTypeNames = true;
}
public override void SetUp()
{
base.SetUp();
unresolvedFile = new CSharpUnresolvedFile();
unresolvedFile.RootUsingScope.Usings.Add(MakeReference("System"));
unresolvedFile.RootUsingScope.Usings.Add(MakeReference("System.Collections.Generic"));
unresolvedFile.RootUsingScope.Usings.Add(MakeReference("System.Linq"));
convertVisitor = new CodeDomConvertVisitor();
convertVisitor.AllowSnippetNodes = false;
convertVisitor.UseFullyQualifiedTypeNames = true;
}
public void ResolveTypeWithUnknownAttributes()
{
const String source = "namespace ns\r\n" +
"{\r\n" +
" public enum EE {v1 = 13, v2 = 666}\r\n" +
" [System.AttributeUsage(System.AttributeTargets.Method | System.AttributeTargets.Property, AllowMultiple = true)]\r\n" +
" public class AttrA : System.Attribute\r\n" +
" {\r\n" +
" }\r\n" +
" [System.AttributeUsage(System.AttributeTargets.Method)]\r\n" +
" public class AttrB : System.Attribute\r\n" +
" {\r\n" +
" public AttrB(int i, string s, EE e) {}\r\n" +
" }\r\n" +
" public class SomeClass\r\n" +
" {\r\n" +
" [AttrA]\r\n" +
" [AttrB(666, \"iddqd\", EE.v1)]\r\n" +
" [AttrC]\r\n" +
" public void M()\r\n" +
" { }\r\n" +
" }\r\n" +
"}";
CSharpParser parser = new CSharpParser();
SyntaxTree syntaxTree = parser.Parse(source);
syntaxTree.FileName = "example.cs";
CSharpUnresolvedFile unresolvedTypeSystem = syntaxTree.ToTypeSystem();
IProjectContent content = new CSharpProjectContent();
content = content.AddOrUpdateFiles(unresolvedTypeSystem);
CecilLoader loader = new CecilLoader();
AssemblyDefinition mscorlibAssemblyDefinition = AssemblyDefinition.ReadAssembly(typeof(Object).Assembly.Location);
IUnresolvedAssembly mscorlibAssembly = loader.LoadAssembly(mscorlibAssemblyDefinition);
content = content.AddAssemblyReferences(mscorlibAssembly);
ICompilation compilation = content.CreateCompilation();
CSharpAstResolver resolver = new CSharpAstResolver(compilation, syntaxTree);
MethodDeclaration method = syntaxTree.Descendants.OfType <MethodDeclaration>().First(m => m.Name == "M");
ResolveResult result = resolver.Resolve(method);
MemberResolveResult memberResult = (MemberResolveResult)result;
IMember member = memberResult.Member;
foreach (IAttribute attribute in member.Attributes)
{
Console.WriteLine("attribute.AttributeType = {0}, attribute.AttributeType.Kind = {1}", attribute.AttributeType.FullName, attribute.AttributeType.Kind);
Console.WriteLine("attribute.PositionalArguments.Count = {0}", attribute.PositionalArguments.Count);
ProcessPositionalArgs(attribute.PositionalArguments);
Console.WriteLine("attribute.NamedArguments.Count = {0}", attribute.NamedArguments.Count);
Console.WriteLine();
}
}
public override bool GetParameterCompletionCommandOffset(out int cpos)
{
var engine = new CSharpParameterCompletionEngine(
TextEditorData.Document,
typeSystemSegmentTree,
this,
Document.GetProjectContext(),
CSharpUnresolvedFile.GetTypeResolveContext(Document.Compilation, document.Editor.Caret.Location) as CSharpTypeResolveContext
);
engine.SetOffset(document.Editor.Caret.Offset);
return(engine.GetParameterCompletionCommandOffset(out cpos));
}
public CSharpFullParseInformation(CSharpUnresolvedFile unresolvedFile, ITextSourceVersion parsedVersion, SyntaxTree compilationUnit)
: base(unresolvedFile, parsedVersion, isFullParseInformation: true)
{
if (unresolvedFile == null)
{
throw new ArgumentNullException("unresolvedFile");
}
if (compilationUnit == null)
{
throw new ArgumentNullException("compilationUnit");
}
this.syntaxTree = compilationUnit;
}
public DefaultCompletionContextProvider(IDocument document, CSharpUnresolvedFile unresolvedFile)
{
if (document == null)
{
throw new ArgumentNullException("document");
}
if (unresolvedFile == null)
{
throw new ArgumentNullException("unresolvedFile");
}
this.document = document;
this.unresolvedFile = unresolvedFile;
}
public CSharpFile(CSharpProject project, FileName fileName)
{
this.Project = project;
this.FileName = fileName;
this.OriginalText = File.ReadAllText(fileName);
CSharpParser p = new CSharpParser(project.CompilerSettings);
this.SyntaxTree = p.Parse(this.OriginalText, fileName);
this.UnresolvedTypeSystemForFile = SD.ParserService.GetExistingUnresolvedFile(fileName, null, project.IProject) as CSharpUnresolvedFile;
if (this.UnresolvedTypeSystemForFile == null)
{
throw new InvalidOperationException("LoadSolutionProjectsThread not yet finished?");
}
}
public void SetUp()
{
pc = new CSharpProjectContent();
pc = pc.SetAssemblyName("MyAssembly");
unresolvedFile = SyntaxTree.Parse(program, "program.cs").ToTypeSystem();
pc = pc.AddOrUpdateFiles(unresolvedFile);
pc = pc.AddAssemblyReferences(new [] { CecilLoaderTests.Mscorlib });
compilation = pc.CreateCompilation();
baseClass = compilation.RootNamespace.GetTypeDefinition("Base", 1);
nestedClass = baseClass.NestedTypes.Single();
derivedClass = compilation.RootNamespace.GetTypeDefinition("Derived", 2);
systemClass = compilation.RootNamespace.GetChildNamespace("NS").GetTypeDefinition("System", 0);
}
public void SetUp()
{
pc = new CSharpProjectContent();
pc = pc.SetAssemblyName("MyAssembly");
unresolvedFile = SyntaxTree.Parse(program, "program.cs").ToTypeSystem();
pc = pc.AddOrUpdateFiles(unresolvedFile);
pc = pc.AddAssemblyReferences(new [] { CecilLoaderTests.Mscorlib });
compilation = pc.CreateCompilation();
baseClass = compilation.RootNamespace.GetTypeDefinition("Base", 1);
nestedClass = baseClass.NestedTypes.Single();
derivedClass = compilation.RootNamespace.GetTypeDefinition("Derived", 2);
systemClass = compilation.RootNamespace.GetChildNamespace("NS").GetTypeDefinition("System", 0);
}
private CSharpCompletionContext(ITextEditor editor, IList<string> conditionalSymbols, ICompilation compilation, IProjectContent projectContent, IDocument document, CSharpUnresolvedFile unresolvedFile, TextLocation caretLocation)
{
Debug.Assert(editor != null);
Debug.Assert(unresolvedFile != null);
Debug.Assert(compilation != null);
Debug.Assert(projectContent != null);
Debug.Assert(document != null);
this.Editor = editor;
this.Document = document;
this.ConditionalSymbols = conditionalSymbols;
this.Compilation = compilation;
this.ProjectContent = projectContent;
this.TypeResolveContextAtCaret = unresolvedFile.GetTypeResolveContext(compilation, caretLocation);
this.CompletionContextProvider = new DefaultCompletionContextProvider(document, unresolvedFile);
this.CompletionContextProvider.ConditionalSymbols.AddRange(conditionalSymbols);
}
public CSharpFile(NRefactory.CSharpProject project, string fileName, string sourceCode)
{
_project = project;
FileName = fileName;
var parser = new CSharpParser(project.CompilerSettings);
// Keep the original text around; we might use it for a refactoring later
OriginalText = sourceCode;
SyntaxTree = parser.Parse(OriginalText, fileName);
_errors = parser.HasErrors
? parser.ErrorsAndWarnings
: new List<Error>(0);
UnresolvedTypeSystemForFile = SyntaxTree.ToTypeSystem();
}
public CSharpFile(CSharpProject project, FilePath fileName, string sourceCode)
{
Ensure.ArgumentNotNull(project, "project");
Project = project;
FileName = fileName;
OriginalText = sourceCode;
var parser = new CSharpParser(Project.CompilerSettings);
SyntaxTree = parser.Parse(sourceCode, fileName.FullPath);
Errors = parser.HasErrors
? parser.ErrorsAndWarnings
: new List<Error>(0);
UnresolvedTypeSystemForFile = SyntaxTree.ToTypeSystem();
}
public MethodParameterDataProvider (int startOffset, CSharpCompletionTextEditorExtension ext, IEnumerable<IMethod> m) : base (ext, startOffset)
{
compilation = ext.UnresolvedFileCompilation;
file = ext.CSharpUnresolvedFile;
HashSet<string> alreadyAdded = new HashSet<string> ();
foreach (var method in m) {
if (method.IsConstructor)
continue;
if (!method.IsBrowsable ())
continue;
string str = ambience.GetString (method, OutputFlags.IncludeParameters | OutputFlags.GeneralizeGenerics | OutputFlags.IncludeGenerics);
if (alreadyAdded.Contains (str))
continue;
alreadyAdded.Add (str);
methods.Add (method);
}
methods.Sort (MethodComparer);
}
private void Prepare(string source, Action preparer) {
IProjectContent project = new CSharpProjectContent();
var parser = new CSharpParser();
using (var rdr = new StringReader(source)) {
var pf = new CSharpUnresolvedFile("File.cs");
var syntaxTree = parser.Parse(rdr, pf.FileName);
syntaxTree.AcceptVisitor(new TypeSystemConvertVisitor(pf));
project = project.AddOrUpdateFiles(pf);
}
project = project.AddAssemblyReferences(new[] { Files.Mscorlib });
var compilation = project.CreateCompilation();
AllTypes = compilation.MainAssembly.TopLevelTypeDefinitions.SelectMany(SelfAndNested).ToDictionary(t => t.ReflectionName);
var er = new MockErrorReporter(true);
Metadata = new MetadataImporter(er, compilation, new CompilerOptions());
preparer();
Metadata.Prepare(compilation.GetAllTypeDefinitions());
Assert.That(er.AllMessages, Is.Empty, "Should not generate errrors");
}
public CSharpFile(CSharpProject project, string fileName)
{
this.Project = project;
this.FileName = fileName;
CSharpParser p = new CSharpParser(project.CompilerSettings);
// using (var stream = File.OpenRead(fileName)) {
// this.CompilationUnit = p.Parse(stream, fileName);
// }
// Keep the original text around; we might use it for a refactoring later
this.OriginalText = File.ReadAllText(fileName);
this.SyntaxTree = p.Parse(this.OriginalText, fileName);
if (p.HasErrors) {
Console.WriteLine("Error parsing " + fileName + ":");
foreach (var error in p.ErrorsAndWarnings) {
Console.WriteLine(" " + error.Region + " " + error.Message);
}
}
this.UnresolvedTypeSystemForFile = this.SyntaxTree.ToTypeSystem();
}
/// <summary>
/// Creates a new C# AST resolver.
/// Use this overload if you are resolving code snippets (not necessarily complete files).
/// </summary>
/// <param name="resolver">The resolver state at the root node (to be more precise: just outside the root node).</param>
/// <param name="rootNode">The root node of the tree to be resolved.</param>
/// <param name="unresolvedFile">
/// Optional: Result of <see cref="SyntaxTree.ToTypeSystem()"/> for the file being resolved.
/// <para>
/// This is used for setting up the context on the resolver. The unresolved file must be registered in the compilation.
/// </para>
/// <para>
/// When a unresolvedFile is specified, the resolver will use the member's StartLocation/EndLocation to identify
/// member declarations in the AST with members in the type system.
/// When no unresolvedFile is specified (<c>null</c> value for this parameter), the resolver will instead compare the
/// member's signature in the AST with the signature in the type system.
/// </para>
/// </param>
public CSharpAstResolver(CSharpResolver resolver, AstNode rootNode, CSharpUnresolvedFile unresolvedFile = null)
{
if (resolver == null)
throw new ArgumentNullException("resolver");
if (rootNode == null)
throw new ArgumentNullException("rootNode");
this.initialResolverState = resolver;
this.rootNode = rootNode;
this.unresolvedFile = unresolvedFile;
this.resolveVisitor = new ResolveVisitor(initialResolverState, unresolvedFile);
}
public AstType CreateShortType (ICompilation compilation, CSharpUnresolvedFile parsedFile, TextLocation loc, IType fullType)
{
var csResolver = parsedFile.GetResolver (compilation, loc);
var builder = new ICSharpCode.NRefactory.CSharp.Refactoring.TypeSystemAstBuilder (csResolver);
return builder.ConvertType (fullType);
}
/// <summary>
/// Finds all references of a given type parameter.
/// </summary>
/// <param name="typeParameter">The type parameter for which to look.</param>
/// <param name="unresolvedFile">The type system representation of the file being searched.</param>
/// <param name="syntaxTree">The syntax tree of the file being searched.</param>
/// <param name="compilation">The compilation.</param>
/// <param name="callback">Callback used to report the references that were found.</param>
/// <param name="cancellationToken">Cancellation token that may be used to cancel the operation.</param>
public void FindTypeParameterReferences(IType typeParameter, CSharpUnresolvedFile unresolvedFile, SyntaxTree syntaxTree,
ICompilation compilation, FoundReferenceCallback callback, CancellationToken cancellationToken)
{
if (typeParameter == null)
throw new ArgumentNullException("typeParameter");
if (typeParameter.Kind != TypeKind.TypeParameter)
throw new ArgumentOutOfRangeException("typeParameter", "Only type parameters are allowed");
var searchScope = new SearchScope(c => new FindTypeParameterReferencesNavigator((ITypeParameter)typeParameter));
searchScope.declarationCompilation = compilation;
searchScope.accessibility = Accessibility.Private;
FindReferencesInFile(searchScope, unresolvedFile, syntaxTree, compilation, callback, cancellationToken);
}
/// <summary>
/// Finds all references in the given file.
/// </summary>
/// <param name="searchScopes">The search scopes for which to look.</param>
/// <param name="unresolvedFile">The type system representation of the file being searched.</param>
/// <param name="syntaxTree">The syntax tree of the file being searched.</param>
/// <param name="compilation">The compilation for the project that contains the file.</param>
/// <param name="callback">Callback used to report the references that were found.</param>
/// <param name="cancellationToken">CancellationToken that may be used to cancel the operation.</param>
public void FindReferencesInFile(IList<IFindReferenceSearchScope> searchScopes, CSharpUnresolvedFile unresolvedFile, SyntaxTree syntaxTree,
ICompilation compilation, FoundReferenceCallback callback, CancellationToken cancellationToken)
{
if (searchScopes == null)
throw new ArgumentNullException("searchScopes");
if (syntaxTree == null)
throw new ArgumentNullException("syntaxTree");
if (compilation == null)
throw new ArgumentNullException("compilation");
if (callback == null)
throw new ArgumentNullException("callback");
if (searchScopes.Count == 0)
return;
var navigators = new IResolveVisitorNavigator[searchScopes.Count];
for (int i = 0; i < navigators.Length; i++) {
navigators[i] = searchScopes[i].GetNavigator(compilation, callback);
}
IResolveVisitorNavigator combinedNavigator;
if (searchScopes.Count == 1) {
combinedNavigator = navigators[0];
} else {
combinedNavigator = new CompositeResolveVisitorNavigator(navigators);
}
cancellationToken.ThrowIfCancellationRequested();
combinedNavigator = new DetectSkippableNodesNavigator(combinedNavigator, syntaxTree);
cancellationToken.ThrowIfCancellationRequested();
CSharpAstResolver resolver = new CSharpAstResolver(compilation, syntaxTree, unresolvedFile);
resolver.ApplyNavigator(combinedNavigator, cancellationToken);
foreach (var n in navigators) {
var frn = n as FindReferenceNavigator;
if (frn != null)
frn.NavigatorDone(resolver, cancellationToken);
}
}
/// <summary>
/// Finds all references in the given file.
/// </summary>
/// <param name="searchScope">The search scope for which to look.</param>
/// <param name="unresolvedFile">The type system representation of the file being searched.</param>
/// <param name="syntaxTree">The syntax tree of the file being searched.</param>
/// <param name="compilation">The compilation for the project that contains the file.</param>
/// <param name="callback">Callback used to report the references that were found.</param>
/// <param name="cancellationToken">CancellationToken that may be used to cancel the operation.</param>
public void FindReferencesInFile(IFindReferenceSearchScope searchScope, CSharpUnresolvedFile unresolvedFile, SyntaxTree syntaxTree,
ICompilation compilation, FoundReferenceCallback callback, CancellationToken cancellationToken)
{
if (searchScope == null)
throw new ArgumentNullException("searchScope");
FindReferencesInFile(new[] { searchScope }, unresolvedFile, syntaxTree, compilation, callback, cancellationToken);
}
/// <summary>
/// Finds all references of a given variable.
/// </summary>
/// <param name="variable">The variable for which to look.</param>
/// <param name="unresolvedFile">The type system representation of the file being searched.</param>
/// <param name="syntaxTree">The syntax tree of the file being searched.</param>
/// <param name="compilation">The compilation.</param>
/// <param name="callback">Callback used to report the references that were found.</param>
/// <param name="cancellationToken">Cancellation token that may be used to cancel the operation.</param>
public void FindLocalReferences(IVariable variable, CSharpUnresolvedFile unresolvedFile, SyntaxTree syntaxTree,
ICompilation compilation, FoundReferenceCallback callback, CancellationToken cancellationToken)
{
if (variable == null)
throw new ArgumentNullException("variable");
var searchScope = new SearchScope(c => new FindLocalReferencesNavigator(variable));
searchScope.declarationCompilation = compilation;
FindReferencesInFile(searchScope, unresolvedFile, syntaxTree, compilation, callback, cancellationToken);
}
public ParsedSourceFile(SyntaxTree syntaxTree, CSharpUnresolvedFile parsedFile)
{
SyntaxTree = syntaxTree;
ParsedFile = parsedFile;
}
public static TooltipInformation CreateTooltipInformation (CSharpCompletionTextEditorExtension ext, ICompilation compilation, CSharpUnresolvedFile file, IParameterizedMember entity, int currentParameter, bool smartWrap)
{
return CreateTooltipInformation (compilation, file, ext.TextEditorData, ext.FormattingPolicy, entity, currentParameter, smartWrap);
}
public static TooltipInformation CreateTooltipInformation (ICompilation compilation, CSharpUnresolvedFile file, TextEditorData textEditorData, MonoDevelop.CSharp.Formatting.CSharpFormattingPolicy formattingPolicy, IParameterizedMember entity, int currentParameter, bool smartWrap)
{
var tooltipInfo = new TooltipInformation ();
var resolver = file.GetResolver (compilation, textEditorData.Caret.Location);
var sig = new SignatureMarkupCreator (resolver, formattingPolicy.CreateOptions ());
sig.HighlightParameter = currentParameter;
sig.BreakLineAfterReturnType = smartWrap;
try {
tooltipInfo.SignatureMarkup = sig.GetMarkup (entity);
} catch (Exception e) {
LoggingService.LogError ("Got exception while creating markup for :" + entity, e);
return new TooltipInformation ();
}
tooltipInfo.SummaryMarkup = AmbienceService.GetSummaryMarkup (entity) ?? "";
if (entity is IMethod) {
var method = (IMethod)entity;
if (method.IsExtensionMethod) {
tooltipInfo.AddCategory (GettextCatalog.GetString ("Extension Method from"), method.DeclaringTypeDefinition.FullName);
}
}
int paramIndex = currentParameter;
if (entity is IMethod && ((IMethod)entity).IsExtensionMethod)
paramIndex++;
paramIndex = Math.Min (entity.Parameters.Count - 1, paramIndex);
var curParameter = paramIndex >= 0 && paramIndex < entity.Parameters.Count ? entity.Parameters [paramIndex] : null;
if (curParameter != null) {
string docText = AmbienceService.GetDocumentation (entity);
if (!string.IsNullOrEmpty (docText)) {
string text = docText;
Regex paramRegex = new Regex ("(\\<param\\s+name\\s*=\\s*\"" + curParameter.Name + "\"\\s*\\>.*?\\</param\\>)", RegexOptions.Compiled);
Match match = paramRegex.Match (docText);
if (match.Success) {
text = AmbienceService.GetDocumentationMarkup (entity, match.Groups [1].Value);
if (!string.IsNullOrWhiteSpace (text))
tooltipInfo.AddCategory (GettextCatalog.GetString ("Parameter"), text);
}
}
if (curParameter.Type.Kind == TypeKind.Delegate)
tooltipInfo.AddCategory (GettextCatalog.GetString ("Delegate Info"), sig.GetDelegateInfo (curParameter.Type));
}
return tooltipInfo;
}
protected MethodParameterDataProvider (int startOffset, CSharpCompletionTextEditorExtension ext) : base (ext, startOffset)
{
compilation = ext.UnresolvedFileCompilation;
file = ext.CSharpUnresolvedFile;
}
public static void CreateCompilation (string parsedText, out IProjectContent pctx, out SyntaxTree syntaxTree, out CSharpUnresolvedFile unresolvedFile, bool expectErrors, params IUnresolvedAssembly[] references)
{
pctx = new CSharpProjectContent();
var refs = new List<IUnresolvedAssembly> { mscorlib.Value, systemCore.Value, systemAssembly.Value, systemXmlLinq.Value };
if (references != null)
refs.AddRange (references);
pctx = pctx.AddAssemblyReferences(refs);
syntaxTree = new CSharpParser().Parse(parsedText, "program.cs");
syntaxTree.Freeze();
if (!expectErrors && syntaxTree.Errors.Count > 0) {
Console.WriteLine ("----");
Console.WriteLine (parsedText);
Console.WriteLine ("----");
foreach (var error in syntaxTree.Errors)
Console.WriteLine (error.Message);
Assert.Fail ("Parse error.");
}
unresolvedFile = syntaxTree.ToTypeSystem();
pctx = pctx.AddOrUpdateFiles(unresolvedFile);
}