IUsing CreateUsing(IProjectContent pc, string @namespace)
{
DefaultUsing @using = new DefaultUsing(pc);
@using.Usings.Add(@namespace);
return(@using);
}
public void SetUpFixture()
{
resolver = new PythonResolver();
ParseInformation parseInfo = new ParseInformation();
mockProjectContent = new MockProjectContent();
mockProjectContent.NamespacesToAdd.Add("Test");
myTestClass = new MockClass(mockProjectContent, "MyTestClass");
ArrayList namespaceItems = new ArrayList();
namespaceItems.Add(myTestClass);
mockProjectContent.AddExistingNamespaceContents("MyNamespace", namespaceItems);
DefaultCompilationUnit cu = new DefaultCompilationUnit(mockProjectContent)
{
ErrorsDuringCompile = true
};
parseInfo.SetCompilationUnit(cu);
// Add usings.
DefaultUsing newUsing = new DefaultUsing(cu.ProjectContent);
newUsing.Usings.Add("MyNamespace");
cu.UsingScope.Usings.Add(newUsing);
results = resolver.CtrlSpace(0, "".Length, parseInfo, "", ExpressionContext.Default);
}
public void SetUpFixture()
{
resolver = new PythonResolver();
mockProjectContent = new ICSharpCode.Scripting.Tests.Utils.MockProjectContent();
mockProjectContent.NamespacesToAdd.Add("Test");
myTestClass = new MockClass(mockProjectContent, "MyTestClass");
List <ICompletionEntry> namespaceItems = new List <ICompletionEntry>();
namespaceItems.Add(myTestClass);
mockProjectContent.AddExistingNamespaceContents("MyNamespace", namespaceItems);
DefaultCompilationUnit cu = new DefaultCompilationUnit(mockProjectContent);
// Add usings.
DefaultUsing newUsing = new DefaultUsing(cu.ProjectContent);
newUsing.Usings.Add("MyNamespace");
DefaultUsingScope usingScope = new DefaultUsingScope();
usingScope.Usings.Add(newUsing);
cu.UsingScope = usingScope;
ParseInformation parseInfo = new ParseInformation(cu);
results = resolver.CtrlSpace(0, "".Length, parseInfo, "", ExpressionContext.Default);
}
public StringBuilder GetUsingBuilder()
{
Using(UsingRecoder.Types);
//如果用户想使用自定义的Using
if (AssemblyBuilder.CustomUsingShut)
{
UsingScript = new StringBuilder();
foreach (var @using in _usings)
{
UsingScript.AppendLine($"using {@using};");
}
}
else
{
//使用全局Using
UsingScript.Append(DefaultUsing.DefaultScript);
//把当前域中的using全部加上
Using(AssemblyBuilder.Compiler.Domain.GetPluginAssemblies());
foreach (var @using in _usings)
{
//如果全局已经存在using了，就不加了
if (!DefaultUsing.HasElement(@using))
{
UsingScript.AppendLine($"using {@using};");
}
}
}
return(UsingScript);
}
void UpdateDefaultImports(ICollection <ProjectItem> items)
{
if (languageDefaultImportCount < 0)
{
languageDefaultImportCount = (DefaultImports != null) ? DefaultImports.Usings.Count : 0;
}
if (languageDefaultImportCount == 0)
{
DefaultImports = null;
}
else
{
while (DefaultImports.Usings.Count > languageDefaultImportCount)
{
DefaultImports.Usings.RemoveAt(languageDefaultImportCount);
}
}
foreach (ProjectItem item in items)
{
if (item.ItemType == ItemType.Import)
{
if (DefaultImports == null)
{
DefaultImports = new DefaultUsing(this);
}
DefaultImports.Usings.Add(item.Include);
}
}
}
internal static IEnumerable <UsingDirectiveSyntax> Handler(CompilationUnitSyntax root, HashSet <string> noUseUsings)
{
DefaultUsing.Remove(noUseUsings);
return(from usingDeclaration in root.Usings
where noUseUsings.Contains(usingDeclaration.Name.ToFullString())
select usingDeclaration);
}
DefaultUsing CreateUsing(string namespaceName, IProjectContent projectContent)
{
var defaultUsing = new DefaultUsing(projectContent);
defaultUsing.Usings.Add(namespaceName);
return(defaultUsing);
}
private void NatashaReferenceDomain_LoadAssemblyReferenceWithStream(Assembly assembly, System.IO.Stream stream)
{
References.AddReference(assembly.GetName(), stream);
if (Name == "Default")
{
DefaultUsing.AddUsing(assembly);
}
UsingRecorder.Using(assembly);
}
public StringBuilder GetUsingBuilder()
{
#if DEBUG
Stopwatch stopwatch = new();
stopwatch.Start();
#endif
var usingScript = new StringBuilder();
//如果用户想使用自定义的Using
if (!_useGlobalUsing)
{
foreach (var @using in UsingRecorder._usings)
{
usingScript.AppendLine($"using {@using};");
}
//使用全局Using
if (_autoLoadDomainUsing)
{
foreach (var @using in AssemblyBuilder.Domain.UsingRecorder._usings)
{
if (!UsingRecorder.HasUsing(@using))
{
usingScript.AppendLine($"using {@using};");
}
}
}
}
else
{
//使用全局Using
if (_autoLoadDomainUsing && AssemblyBuilder.Domain.Name != "Default")
{
foreach (var @using in AssemblyBuilder.Domain.UsingRecorder._usings)
{
if (!DefaultUsing.HasElement(@using) && !UsingRecorder.HasUsing(@using))
{
usingScript.AppendLine($"using {@using};");
}
}
}
//把当前域中的using全部加上
foreach (var @using in UsingRecorder._usings)
{
//如果全局已经存在using了，就不加了
if (!DefaultUsing.HasElement(@using))
{
usingScript.AppendLine($"using {@using};");
}
}
usingScript.Append(DefaultUsing.UsingScript);
}
#if DEBUG
stopwatch.StopAndShowCategoreInfo("[using]", "using 组合", 3);
#endif
return(usingScript);
}
private void NatashaReferenceDomain_LoadAssemblyReferencsWithPath(Assembly assembly, string path)
{
References.AddReference(assembly.GetName(), path);
if (Name == "Default")
{
DefaultUsing.AddUsing(assembly);
}
UsingRecorder.Using(assembly);
}
void AddUsing(string requireString)
{
string assemblyName = GetAssemblyName(requireString);
DefaultUsing defaultUsing = new DefaultUsing(compilationUnit.ProjectContent);
defaultUsing.Usings.Add(assemblyName);
compilationUnit.UsingScope.Usings.Add(defaultUsing);
}
public override object VisitUsingDeclaration(AST.UsingDeclaration usingDeclaration, object data)
{
DefaultUsing us = new DefaultUsing(cu.ProjectContent, GetRegion(usingDeclaration.StartLocation, usingDeclaration.EndLocation));
foreach (AST.Using u in usingDeclaration.Usings)
{
u.AcceptVisitor(this, us);
}
currentNamespace.Usings.Add(us);
return(data);
}
public static IEnumerable <UsingDirectiveSyntax> Handler(Diagnostic diagnostic)
{
var root = diagnostic.Location.SourceTree.GetRoot();
var usings = GetUnableUsing(diagnostic, root.ToFullString());
var sets = new HashSet <string>(usings);
DefaultUsing.Remove(sets);
return(from usingDeclaration in root.DescendantNodes()
.OfType <UsingDirectiveSyntax>()
where sets.Contains(usingDeclaration.Name.ToFullString())
select usingDeclaration);
}
public static void AddUsingDeclaration(ICompilationUnit cu, IDocument document, string newNamespace, bool sortExistingUsings)
{
if (cu == null)
{
throw new ArgumentNullException("cu");
}
if (document == null)
{
throw new ArgumentNullException("document");
}
if (newNamespace == null)
{
throw new ArgumentNullException("newNamespace");
}
ParseInformation info = ParserService.ParseFile(cu.FileName, document);
if (info != null)
{
cu = info.CompilationUnit;
}
IUsing newUsingDecl = new DefaultUsing(cu.ProjectContent);
newUsingDecl.Usings.Add(newNamespace);
List <IUsing> newUsings = new List <IUsing>(cu.UsingScope.Usings);
if (sortExistingUsings)
{
newUsings.Sort(CompareUsings);
}
bool inserted = false;
for (int i = 0; i < newUsings.Count; i++)
{
if (CompareUsings(newUsingDecl, newUsings[i]) <= 0)
{
newUsings.Insert(i, newUsingDecl);
inserted = true;
break;
}
}
if (!inserted)
{
newUsings.Add(newUsingDecl);
}
if (sortExistingUsings)
{
PutEmptyLineAfterLastSystemNamespace(newUsings);
}
cu.ProjectContent.Language.CodeGenerator.ReplaceUsings(new RefactoringDocumentAdapter(document), cu.UsingScope.Usings, newUsings);
}
public static IEnumerable <UsingDirectiveSyntax> Handler(CompilationUnitSyntax root, Diagnostic diagnostic)
{
var needToRemove = GetUnableUsing(diagnostic);
var nodes = from usingDeclaration in root.Usings
where usingDeclaration.Name.ToFullString().StartsWith(needToRemove)
select usingDeclaration;
if (nodes != null)
{
DefaultUsing.Remove(nodes.Select(item => item.Name.ToFullString()));
}
return(nodes);
}
public static void RemoveUsingAndNodesFromStartName(this Diagnostic diagnostic, CompilationUnitSyntax root, HashSet <SyntaxNode> removeCollection)
{
var usingNode = GetTypeSyntaxNode <UsingDirectiveSyntax>(diagnostic, root);
if (usingNode != null)
{
var usingNodes = (from usingDeclaration in root.Usings
where usingDeclaration.Name.ToString().StartsWith(usingNode.Name.ToString())
select usingDeclaration).ToList();
removeCollection.UnionWith(usingNodes);
DefaultUsing.Remove(usingNodes.Select(item => item.Name.ToString()));
}
}
public override void OnImport(AST.Import p)
{
DefaultUsing u = new DefaultUsing(_cu.ProjectContent);
if (p.Alias == null)
{
u.Usings.Add(p.Namespace);
}
else
{
u.AddAlias(p.Alias.Name, new GetClassReturnType(_cu.ProjectContent, p.Namespace, 0));
}
_cu.UsingScope.Usings.Add(u);
}
public static IEnumerable <UsingDirectiveSyntax> Handler(Diagnostic diagnostic)
{
var needToRemove = GetUnableUsing(diagnostic);
var nodes = from usingDeclaration in diagnostic.Location.SourceTree.GetRoot()
.DescendantNodes()
.OfType <UsingDirectiveSyntax>()
where usingDeclaration.Name.ToFullString().StartsWith(needToRemove)
select usingDeclaration;
if (nodes != null)
{
DefaultUsing.Remove(nodes.Select(item => item.Name.ToFullString()));
}
return(nodes);
}
public override object VisitUsing(AST.Using u, object data)
{
Debug.Assert(data is DefaultUsing);
DefaultUsing us = (DefaultUsing)data;
if (u.IsAlias)
{
IReturnType rt = CreateReturnType(u.Alias);
if (rt != null)
{
us.AddAlias(u.Name, rt);
}
}
else
{
us.Usings.Add(u.Name);
}
return(data);
}
public override object VisitUsingDeclaration(AST.UsingDeclaration usingDeclaration, object data)
{
DefaultUsing us = new DefaultUsing(cu.ProjectContent, GetRegion(usingDeclaration.StartLocation, usingDeclaration.EndLocation));
foreach (AST.Using u in usingDeclaration.Usings) {
u.AcceptVisitor(this, us);
}
currentNamespace.Usings.Add(us);
return data;
}
void AddUsing(string name, ICompilationUnit compilationUnit)
{
DefaultUsing defaultUsing = CreateUsing(name, compilationUnit.ProjectContent);
compilationUnit.UsingScope.Usings.Add(defaultUsing);
}
public static void RemoveUsingAndNode(this UsingDirectiveSyntax usingDirectiveSyntax, HashSet <SyntaxNode> removeCollection)
{
removeCollection.Add(usingDirectiveSyntax);
DefaultUsing.Remove(usingDirectiveSyntax.Name.ToString());
}
public static void AddDefaultReferenceAndUsing(AssemblyName assemblyName, string path)
{
DefaultDomain.References.AddReference(assemblyName, path);
DefaultUsing.AddUsing(assemblyName);
}
