public void UsingWithAliasing()
{
string program = "using global::System;\n" +
"using myAlias=global::My.Name.Space;\n" +
"using a::b.c;\n";
CSharpParser parser = new CSharpParser();
CompilationUnit cu = parser.Parse(new StringReader(program));
Assert.IsFalse(parser.HasErrors);
Assert.AreEqual(3, cu.Children.Count());
Assert.IsTrue(cu.Children.ElementAt(0) is UsingDeclaration);
Assert.IsFalse(cu.Children.ElementAt(0) is UsingAliasDeclaration);
UsingDeclaration ud = (UsingDeclaration)cu.Children.ElementAt(0);
Assert.AreEqual("global::System", ud.Namespace);
Assert.IsTrue(cu.Children.ElementAt(1) is UsingAliasDeclaration);
UsingAliasDeclaration uad = (UsingAliasDeclaration)cu.Children.ElementAt(1);
Assert.AreEqual("myAlias", uad.Alias);
Assert.AreEqual("global::My.Name.Space", uad.Import.ToString());
Assert.IsTrue(cu.Children.ElementAt(2) is UsingDeclaration);
Assert.IsFalse(cu.Children.ElementAt(2) is UsingAliasDeclaration);
ud = (UsingDeclaration)cu.Children.ElementAt(2);
Assert.AreEqual("a::b.c", ud.Namespace);
}
public void CSharpUsingWithAliasing()
{
string program = "using global::System;\n" +
"using myAlias=global::My.Name.Space;\n" +
"using a::b.c;\n";
IParser parser = ParserFactory.CreateParser(SupportedLanguage.CSharp, new StringReader(program));
parser.Parse();
Assert.AreEqual("", parser.Errors.ErrorOutput);
CompilationUnit u = parser.CompilationUnit;
Assert.AreEqual(3, u.Children.Count);
Assert.IsTrue(u.Children[0] is UsingDeclaration);
UsingDeclaration ud = (UsingDeclaration)u.Children[0];
Assert.AreEqual(1, ud.Usings.Count);
Assert.IsFalse(((Using)ud.Usings[0]).IsAlias);
Assert.AreEqual("System", ud.Usings[0].Name);
Assert.IsTrue(u.Children[1] is UsingDeclaration);
ud = (UsingDeclaration)u.Children[1];
Assert.AreEqual(1, ud.Usings.Count);
Assert.IsTrue(((Using)ud.Usings[0]).IsAlias);
Assert.AreEqual("myAlias", ud.Usings[0].Name);
Assert.AreEqual("My.Name.Space", ud.Usings[0].Alias.Type);
Assert.IsTrue(u.Children[2] is UsingDeclaration);
ud = (UsingDeclaration)u.Children[2];
Assert.AreEqual(1, ud.Usings.Count);
Assert.IsFalse(((Using)ud.Usings[0]).IsAlias);
Assert.AreEqual("a.b.c", ud.Usings[0].Name);
}
void CheckAliases(CompilationUnit u)
{
Assert.AreEqual(3, u.Children.Count);
Assert.IsTrue(u.Children[0] is UsingDeclaration);
UsingDeclaration ud = (UsingDeclaration)u.Children[0];
Assert.AreEqual(1, ud.Usings.Count);
Assert.IsTrue(((Using)ud.Usings[0]).IsAlias);
Assert.AreEqual("TESTME", ud.Usings[0].Name);
Assert.AreEqual("System", ud.Usings[0].Alias.Type);
Assert.IsTrue(u.Children[1] is UsingDeclaration);
ud = (UsingDeclaration)u.Children[1];
Assert.AreEqual(1, ud.Usings.Count);
Assert.IsTrue(((Using)ud.Usings[0]).IsAlias);
Assert.AreEqual("myAlias", ud.Usings[0].Name);
Assert.AreEqual("My.Name.Space", ud.Usings[0].Alias.Type);
Assert.IsTrue(u.Children[2] is UsingDeclaration);
ud = (UsingDeclaration)u.Children[2];
Assert.AreEqual(1, ud.Usings.Count);
Assert.IsTrue(((Using)ud.Usings[0]).IsAlias);
Assert.AreEqual("StringCollection", ud.Usings[0].Name);
Assert.AreEqual("System.Collections.Generic.List", ud.Usings[0].Alias.Type);
Assert.AreEqual("System.String", ud.Usings[0].Alias.GenericTypes[0].Type);
}
public override void VisitUsingDeclaration(UsingDeclaration usingDeclaration)
{
if (!this.Usings.Contains(usingDeclaration.Namespace))
{
this.Usings.Add(usingDeclaration.Namespace);
}
}
public void UsingWithAliasing()
{
string program = "using global::System;\n" +
"using myAlias=global::My.Name.Space;\n" +
"using a::b.c;\n";
CSharpParser parser = new CSharpParser();
SyntaxTree syntaxTree = parser.Parse(program);
Assert.IsFalse(parser.HasErrors);
Assert.IsTrue(3 <= syntaxTree.Children.Count());
Assert.IsTrue(syntaxTree.Children.ElementAt(0) is UsingDeclaration);
Assert.IsFalse(syntaxTree.Children.ElementAt(0) is UsingAliasDeclaration);
UsingDeclaration ud = (UsingDeclaration)syntaxTree.Children.ElementAt(0);
Assert.AreEqual("global::System", ud.Namespace);
Assert.IsTrue(syntaxTree.Children.Where(c => c.Role != Roles.NewLine).ElementAt(1) is UsingAliasDeclaration);
UsingAliasDeclaration uad = (UsingAliasDeclaration)syntaxTree.Children.Where(c => c.Role != Roles.NewLine).ElementAt(1);
Assert.AreEqual("myAlias", uad.Alias);
Assert.AreEqual("global::My.Name.Space", uad.Import.ToString());
Assert.IsTrue(syntaxTree.Children.Where(c => c.Role != Roles.NewLine).ElementAt(2) is UsingDeclaration);
Assert.IsFalse(syntaxTree.Children.Where(c => c.Role != Roles.NewLine).ElementAt(2) is UsingAliasDeclaration);
ud = (UsingDeclaration)syntaxTree.Children.Where(c => c.Role != Roles.NewLine).ElementAt(2);
Assert.AreEqual("a::b.c", ud.Namespace);
}
public void AddUsing(NamespaceDeclaration namespaceDeclaration, IList usings, UsingDeclaration usingDeclaration)
{
Using usin = (Using)usingDeclaration.Usings[0];
string alias = null;
string name = usin.Name;
if (!usin.IsAlias)
{
name = name.Substring(name.LastIndexOf('.') + 1);
}
else
{
alias = usin.Alias.Type;
}
if (CodeBase.References.Contains(name))
{
string reference = (string)CodeBase.References[name];
alias = alias.Replace("." + name, "." + reference);
TypeReference typeReference = AstUtil.GetTypeReference(alias, namespaceDeclaration);
UsingDeclaration addingUsingDeclaration = new UsingDeclaration(reference, typeReference);
if (!Contains(usings, addingUsingDeclaration))
{
namespaceDeclaration.Children.Insert(0, addingUsingDeclaration);
}
}
}
private void MergeUsing(UsingDeclaration child)
{
if (child.Usings.Count != 1)
{
throw new ArgumentOutOfRangeException("child", "didn't expect to have more than 1 in Usings collection");
}
Int32 insertAt = 0;
Boolean add = true;
foreach (INode node in unit.Children)
{
if (node is UsingDeclaration)
{
UsingDeclaration element = node as UsingDeclaration;
if (element.Usings.Count != 1)
{
throw new Exception("didn't expect to have more than 1 in the Usings collection");
}
if (CompareUsingNodes(element, child))
{
add = false;
}
insertAt++;
}
}
if (add)
{
unit.Children.Insert(insertAt, child);
}
}
public UnifiedElement VisitUsingDeclaration(
UsingDeclaration dec, object data)
{
var target = LookupType(dec.Import);
return(UnifiedImport.Create(target));
}
public override object VisitDeclareDeclaration(DeclareDeclaration declareDeclaration, object data)
{
if (usings != null && !usings.ContainsKey("System.Runtime.InteropServices"))
{
UsingDeclaration @using = new UsingDeclaration("System.Runtime.InteropServices");
addedUsings.Add(@using);
base.VisitUsingDeclaration(@using, data);
}
MethodDeclaration method = new MethodDeclaration(declareDeclaration.Name, declareDeclaration.Modifier,
declareDeclaration.TypeReference, declareDeclaration.Parameters,
declareDeclaration.Attributes);
if ((method.Modifier & Modifiers.Visibility) == 0)
{
method.Modifier |= Modifiers.Public;
}
method.Modifier |= Modifiers.Extern | Modifiers.Static;
if (method.TypeReference.IsNull)
{
method.TypeReference = new TypeReference("System.Void");
}
Attribute att = new Attribute("DllImport", null, null);
att.PositionalArguments.Add(CreateStringLiteral(declareDeclaration.Library));
if (declareDeclaration.Alias.Length > 0)
{
att.NamedArguments.Add(new NamedArgumentExpression("EntryPoint", CreateStringLiteral(declareDeclaration.Alias)));
}
switch (declareDeclaration.Charset)
{
case CharsetModifier.Auto:
att.NamedArguments.Add(new NamedArgumentExpression("CharSet",
new FieldReferenceExpression(new IdentifierExpression("CharSet"),
"Auto")));
break;
case CharsetModifier.Unicode:
att.NamedArguments.Add(new NamedArgumentExpression("CharSet",
new FieldReferenceExpression(new IdentifierExpression("CharSet"),
"Unicode")));
break;
default:
att.NamedArguments.Add(new NamedArgumentExpression("CharSet",
new FieldReferenceExpression(new IdentifierExpression("CharSet"),
"Ansi")));
break;
}
att.NamedArguments.Add(new NamedArgumentExpression("SetLastError", new PrimitiveExpression(true, true.ToString())));
att.NamedArguments.Add(new NamedArgumentExpression("ExactSpelling", new PrimitiveExpression(true, true.ToString())));
AttributeSection sec = new AttributeSection(null, null);
sec.Attributes.Add(att);
method.Attributes.Add(sec);
ReplaceCurrentNode(method);
return(base.VisitMethodDeclaration(method, data));
}
public void RemoveCurrentNamespaceUsings()
{
string program = @"package Janett.Translator;
public class Translation
{
}" ;
string expected = @"namespace Janett.Translator
{
public class Translation
{
}
}" ;
CompilationUnit cu = TestUtil.ParseProgram(program);
NamespaceDeclaration ns = (NamespaceDeclaration)cu.Children[0];
UsingDeclaration us1 = new UsingDeclaration("Refactoring", AstUtil.GetTypeReference("Janett.Translator.Refactoring", ns));
UsingDeclaration us2 = new UsingDeclaration("Transformation", AstUtil.GetTypeReference("Janett.Translator.Transformation", ns));
ns.Children.Insert(0, us2);
ns.Children.Insert(0, us1);
us1.Parent = ns;
us2.Parent = ns;
VisitCompilationUnit(cu, null);
TestUtil.CodeEqual(expected, TestUtil.GenerateCode(cu));
}
public virtual void VisitUsingDeclaration(UsingDeclaration usingDeclaration)
{
if (this.ThrowException)
{
throw (System.Exception) this.CreateException(usingDeclaration);
}
}
public virtual void VisitUsingDeclaration(UsingDeclaration usingDeclaration)
{
if (ThrowException)
{
throw (Exception)CreateException(usingDeclaration);
}
}
private bool ContainsUsing(IList usingList, UsingDeclaration usingDec)
{
foreach (UsingDeclaration usi in usingList)
{
Using usingDeclared = (Using)usingDec.Usings[0];
Using usiUsing = (Using)usi.Usings[0];
if (usiUsing.IsAlias && usingDeclared.IsAlias)
{
if (usiUsing.Name == usingDeclared.Name &&
usiUsing.Alias.Type == usingDeclared.Alias.Type)
{
return(true);
}
}
else if (!(usiUsing.IsAlias && usingDeclared.IsAlias))
{
if (usingDeclared.Name == usiUsing.Name)
{
return(true);
}
}
}
return(false);
}
public override object VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data)
{
base.VisitUsingDeclaration(usingDeclaration, data);
if (usingDeclaration.Usings.Count == 0) {
RemoveCurrentNode();
}
return null;
}
public object VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data)
{
foreach (Using u in usingDeclaration.Usings)
{
VisitUsing(u, data);
}
return(null);
}
public override object Visit(UsingDeclaration usingDeclaration, object data)
{
foreach (Using u in usingDeclaration.Usings)
{
namespaceDeclarations.Peek().Imports.Add(new CodeNamespaceImport(u.Name));
}
return(null);
}
public override void VisitUsingDeclaration(UsingDeclaration usingDeclaration)
{
if (IsSuppressed(usingDeclaration.StartLocation))
{
return;
}
declarations.Add(new UsingDeclarationSpecifier(usingDeclaration));
}
public override object VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data)
{
if (firstType)
{
includeCommentsUpToLine = usingDeclaration.EndLocation.Y;
}
return(null);
}
public override object VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data)
{
foreach (Using us in usingDeclaration.Usings)
{
us.Parent = usingDeclaration;
}
return(base.VisitUsingDeclaration(usingDeclaration, data));
}
public override object VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data)
{
foreach (var declaration in usingDeclaration.Usings)
{
UsingDeclarations.Add(new AstValue <UsingDeclaration>(declaration.Name, usingDeclaration, usingDeclaration.StartLocation, usingDeclaration.EndLocation));
}
return(null);
}
public Ust VisitImportDeclaration(JavaParser.ImportDeclarationContext context)
{
StringLiteral name = (StringLiteral)Visit(context.qualifiedName());
TextSpan textSpan = context.GetTextSpan();
var result = new UsingDeclaration(name, textSpan);
return(result);
}
public virtual object Visit(UsingDeclaration usingDeclaration, object data)
{
Debug.Assert(usingDeclaration != null);
foreach (Using ud in usingDeclaration.Usings)
{
ud.AcceptVisitor(this, data);
}
return(data);
}
public override object VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data)
{
base.VisitUsingDeclaration(usingDeclaration, data);
if (usingDeclaration.Parent is NamespaceDeclaration) {
nodesToMoveToCompilationUnit.Add(usingDeclaration);
RemoveCurrentNode();
}
return null;
}
public void ParseFile()
{
foreach (var v in file.Children)
{
if (v is Comment)
{
Comment _v = v as Comment;
Append(_v.ToString().Replace("\r\n", ""));
}
else if (v is UsingDeclaration)
{
UsingDeclaration _v = v as UsingDeclaration;
string usingname = Tools._getUsingFullName(v);
listUsing.Add(usingname);
Append("//<C#>using " + usingname + ";");
}
else if (v is UsingAliasDeclaration)
{
string usingname = Tools._getUsingFullName(v);
string id = Tools._getIdentifier(v);
listUsinAlias.Add(id, usingname);
Append("import " + id + "=" + usingname + ";");
}
else if (v is NewLineNode)
{
AppendLine();
}
else if (v is NamespaceDeclaration)
{
string names = Tools._getFirstType(v);
string oldCurNameSpace = curNamespace;
if (string.IsNullOrEmpty(curNamespace))
{
curNamespace = names;
}
else
{
curNamespace += "." + names;
}
ParseNameSpace(names, v);
curNamespace = oldCurNameSpace;
}
else if (v is TypeDeclaration)
{
var cname = Tools._getIdentifier(v);
string oldclass = curClassName;
ParseClass(cname, v);//处理完恢复一下当前classname
curClassName = oldclass;
}
else
{
logger.LogError("not support file element:" + v.GetType() + "|" + v.NodeType + "|" + v.StartLocation.Line);
}
}
}
/// <summary>
/// Visits a using declaration.
/// </summary>
private void VisitUsingDeclaration()
{
var node = new UsingDeclaration(base.TokenStream.Program);
node.UsingKeyword = base.TokenStream.Peek();
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
if (base.TokenStream.Done ||
base.TokenStream.Peek().Type != TokenType.Identifier)
{
throw new ParsingException("Expected identifier.",
new List <TokenType>
{
TokenType.Identifier
});
}
while (!base.TokenStream.Done &&
base.TokenStream.Peek().Type != TokenType.Semicolon)
{
if (base.TokenStream.Peek().Type != TokenType.Identifier &&
base.TokenStream.Peek().Type != TokenType.Dot &&
base.TokenStream.Peek().Type != TokenType.NewLine)
{
throw new ParsingException("Expected identifier.",
new List <TokenType>
{
TokenType.Identifier,
TokenType.Dot
});
}
else
{
node.IdentifierTokens.Add(base.TokenStream.Peek());
}
base.TokenStream.Index++;
base.TokenStream.SkipWhiteSpaceAndCommentTokens();
}
if (base.TokenStream.Done ||
base.TokenStream.Peek().Type != TokenType.Semicolon)
{
throw new ParsingException("Expected \";\".",
new List <TokenType>
{
TokenType.Semicolon
});
}
node.SemicolonToken = base.TokenStream.Peek();
(this.Program as PSharpProgram).UsingDeclarations.Add(node);
}
public override object VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data)
{
base.VisitUsingDeclaration(usingDeclaration, data);
if (usingDeclaration.Parent is NamespaceDeclaration)
{
nodesToMoveToCompilationUnit.Add(usingDeclaration);
RemoveCurrentNode();
}
return(null);
}
public override IUnresolvedEntity VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data)
{
TypeOrNamespaceReference u = usingDeclaration.Import.ToTypeReference(SimpleNameLookupMode.TypeInUsingDeclaration) as TypeOrNamespaceReference;
if (u != null) {
if (interningProvider != null)
u = interningProvider.Intern(u);
usingScope.Usings.Add(u);
}
return null;
}
public override object TrackedVisitUsingDeclaration(UsingDeclaration usingDeclaration, object data)
{
Using usi = (Using)usingDeclaration.Usings[0];
string type = GetShortReferenceTypeName(usi);
if (similarTypes.Contains(type))
{
RemoveCurrentNode();
}
return(null);
}
public override object TrackedVisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data)
{
NamespaceDeclaration replacedNamespace = namespaceDeclaration;
UsingDeclaration usingDeclaration = new UsingDeclaration("java.lang.*");
replacedNamespace.Children.Insert(0, usingDeclaration);
ReplaceCurrentNode(replacedNamespace);
return(base.TrackedVisitNamespaceDeclaration(namespaceDeclaration, data));
}
public override void VisitUsingDeclaration(UsingDeclaration usingDeclaration)
{
base.VisitUsingDeclaration(usingDeclaration);
var nrr = ctx.Resolve(usingDeclaration.Import) as NamespaceResolveResult;
if (nrr != null)
{
isInUse[usingDeclaration] = inspector.namespacesToKeep.Contains(nrr.NamespaceName);
namespaceToUsingDecl[nrr.NamespaceName] = usingDeclaration;
}
}
private void handleUsing(UsingDeclaration usng)
{
_writer.WriteUsing(
new Using(
_file,
usng.Namespace,
usng.Import.StartLocation.Line,
usng.Import.StartLocation.Column)
.SetEndPosition(
usng.SemicolonToken.EndLocation.Line,
usng.SemicolonToken.EndLocation.Column));
}
void HandleVisitorUsingDeclarationVisited (UsingDeclaration node, InspectionData data)
{
if (!data.Graph.UsedUsings.Contains (node.Namespace)) {
AddResult (data,
new DomRegion (node.StartLocation.Line, node.StartLocation.Column, node.EndLocation.Line, node.EndLocation.Column),
GettextCatalog.GetString ("Remove unused usings"),
delegate {
RefactoringOptions options = new RefactoringOptions () { Document = data.Document, Dom = data.Document.Dom};
new RemoveUnusedImportsRefactoring ().Run (options);
}
);
}
}
public override void VisitUsingDeclaration(UsingDeclaration usingDeclaration)
{
if (!this.Usings.Contains(usingDeclaration.Namespace))
{
this.Usings.Add(usingDeclaration.Namespace);
}
}
public override void VisitUsingDeclaration(UsingDeclaration usingDeclaration)
{
if (!(usingDeclaration.PrevSibling is UsingDeclaration || usingDeclaration.PrevSibling is UsingAliasDeclaration)) {
EnsureBlankLinesBefore(usingDeclaration, policy.BlankLinesBeforeUsings);
}
if (!(usingDeclaration.NextSibling is UsingDeclaration || usingDeclaration.NextSibling is UsingAliasDeclaration)) {
EnsureBlankLinesAfter(usingDeclaration, policy.BlankLinesAfterUsings);
}
}
public void VisitUsingDeclaration(UsingDeclaration node)
{
VisitChildren(node);
}
public override List<Change> PerformChanges (RefactoringOptions options, object properties)
{
List<Change> result = new List<Change> ();
ICompilationUnit compilationUnit = options.ParseDocument ().CompilationUnit;
Mono.TextEditor.TextEditorData textEditorData = options.GetTextEditorData ();
int minOffset = int.MaxValue;
foreach (IUsing u in compilationUnit.Usings) {
if (u.IsFromNamespace)
continue;
int offset = textEditorData.Document.LocationToOffset (u.Region.Start.Line, u.Region.Start.Column);
TextReplaceChange change = new TextReplaceChange () {
FileName = options.Document.FileName,
Offset = offset,
RemovedChars = textEditorData.Document.LocationToOffset (u.Region.End.Line, u.Region.End.Column) - offset
};
Mono.TextEditor.LineSegment line = textEditorData.Document.GetLineByOffset (change.Offset);
if (line != null && line.EditableLength == change.RemovedChars)
change.RemovedChars += line.DelimiterLength;
result.Add (change);
minOffset = Math.Min (minOffset, offset);
}
StringBuilder output = new StringBuilder ();
List<IUsing> usings = new List<IUsing> (compilationUnit.Usings);
usings.Sort (UsingComparer);
INRefactoryASTProvider astProvider = options.GetASTProvider ();
foreach (IUsing u in usings) {
AstNode declaration;
if (u.IsFromNamespace)
continue;
if (u.Aliases.Any ()) {
KeyValuePair<string, IReturnType> alias = u.Aliases.First ();
declaration = new UsingAliasDeclaration (alias.Key, alias.Value.ConvertToTypeReference ());
} else {
declaration = new UsingDeclaration (u.Namespaces.First ());
}
output.Append (astProvider.OutputNode (options.Dom, declaration));
}
TextReplaceChange insertSortedUsings = new TextReplaceChange () {
FileName = options.Document.FileName,
Offset = minOffset,
InsertedText = output.ToString ()
};
result.Add (insertSortedUsings);
return result;
}
public override void VisitUsingDeclaration(UsingDeclaration usingDeclaration)
{
base.VisitUsingDeclaration(usingDeclaration);
var nrr = ctx.Resolve(usingDeclaration.Import) as NamespaceResolveResult;
if (nrr != null) {
isInUse[usingDeclaration] = inspector.namespacesToKeep.Contains(nrr.NamespaceName);
namespaceToUsingDecl[nrr.NamespaceName] = usingDeclaration;
}
}
public virtual object VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data) {
Debug.Assert((usingDeclaration != null));
Debug.Assert((usingDeclaration.Usings != null));
for (int i = 0; i < usingDeclaration.Usings.Count; i++) {
Using o = usingDeclaration.Usings[i];
Debug.Assert(o != null);
nodeStack.Push(o);
o.AcceptVisitor(this, data);
o = (Using)nodeStack.Pop();
if (o == null)
usingDeclaration.Usings.RemoveAt(i--);
else
usingDeclaration.Usings[i] = o;
}
return null;
}
public virtual object VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data) {
throw new global::System.NotImplementedException("UsingDeclaration");
}
public virtual object TrackedVisitUsingDeclaration(UsingDeclaration usingDeclaration, object data) {
return base.VisitUsingDeclaration(usingDeclaration, data);
}
public void VisitUsingDeclaration(UsingDeclaration usingDeclaration)
{
JsonObject declaration = new JsonObject();
declaration.Comment = "VisitUsingDeclaration";
AddKeyword(declaration, UsingDeclaration.UsingKeywordRole);
declaration.AddJsonValue("import", GenerateNamespaceString(usingDeclaration.Import));
Push(declaration);
}
public override void VisitUsingDeclaration(UsingDeclaration usingDeclaration)
{
if (usingDeclaration.PrevSibling != null && !(usingDeclaration.PrevSibling is UsingDeclaration || usingDeclaration.PrevSibling is UsingAliasDeclaration)) {
FixIndentationForceNewLine(usingDeclaration.StartLocation);
EnsureBlankLinesBefore(usingDeclaration, policy.BlankLinesBeforeUsings);
} else if (!(usingDeclaration.NextSibling is UsingDeclaration || usingDeclaration.NextSibling is UsingAliasDeclaration)) {
FixIndentationForceNewLine(usingDeclaration.StartLocation);
EnsureBlankLinesAfter(usingDeclaration, policy.BlankLinesAfterUsings);
} else {
FixIndentationForceNewLine(usingDeclaration.StartLocation);
}
}
public virtual object VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data) {
Debug.Assert((usingDeclaration != null));
Debug.Assert((usingDeclaration.Usings != null));
foreach (Using o in usingDeclaration.Usings) {
Debug.Assert(o != null);
o.AcceptVisitor(this, data);
}
return null;
}
public override void VisitUsingDeclaration(UsingDeclaration usingDeclaration)
{
}
public virtual void VisitUsingDeclaration(UsingDeclaration usingDeclaration)
{
if (this.ThrowException)
{
throw (Exception)this.CreateException(usingDeclaration);
}
}
public virtual void VisitUsingDeclaration (UsingDeclaration usingDeclaration)
{
VisitChildren (usingDeclaration);
}
public override void VisitUsingDeclaration(UsingDeclaration usingDeclaration)
{
ForceSpacesAfter(usingDeclaration.UsingToken, true);
FixSemicolon(usingDeclaration.SemicolonToken);
}
public void VisitUsingDeclaration(UsingDeclaration usingDeclaration)
{
StartNode(usingDeclaration);
WriteKeyword(UsingDeclaration.UsingKeywordRole);
usingDeclaration.Import.AcceptVisitor(this);
Semicolon();
EndNode(usingDeclaration);
}
private void UsingDirective()
{
string qualident = null;
TypeReference type = null;
base.Expect(120);
Point location = this.t.Location;
this.Qualident(out qualident);
if (this.la.kind == 3)
{
base.lexer.NextToken();
this.NonArrayType(out type);
}
base.Expect(11);
if ((qualident != null) && (qualident.Length > 0))
{
INode node;
if (type != null)
{
node = new UsingDeclaration(qualident, type);
}
else
{
node = new UsingDeclaration(qualident);
}
node.StartLocation = location;
node.EndLocation = this.t.EndLocation;
base.compilationUnit.AddChild(node);
}
}
public override void Visit (UsingsBag.Using u)
{
UsingDeclaration ud = new UsingDeclaration ();
ud.AddChild (new CSharpTokenNode (Convert (u.UsingLocation), "using".Length), UsingDeclaration.Roles.Keyword);
ud.AddChild (ConvertToType (u.NSpace), UsingDeclaration.ImportRole);
ud.AddChild (new CSharpTokenNode (Convert (u.SemicolonLocation), 1), UsingDeclaration.Roles.Semicolon);
AddToNamespace (ud);
}
public sealed override object VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data) {
BeginVisit(usingDeclaration);
object result = TrackedVisitUsingDeclaration(usingDeclaration, data);
EndVisit(usingDeclaration);
return result;
}
void UsingDirective() {
#line 190 "cs.ATG"
string qualident = null; TypeReference aliasedType = null;
Expect(121);
#line 193 "cs.ATG"
Location startPos = t.Location;
Qualident(
#line 194 "cs.ATG"
out qualident);
if (la.kind == 3) {
lexer.NextToken();
NonArrayType(
#line 195 "cs.ATG"
out aliasedType);
}
Expect(11);
#line 197 "cs.ATG"
if (qualident != null && qualident.Length > 0) {
INode node;
if (aliasedType != null) {
node = new UsingDeclaration(qualident, aliasedType);
} else {
node = new UsingDeclaration(qualident);
}
node.StartLocation = startPos;
node.EndLocation = t.EndLocation;
compilationUnit.AddChild(node);
}
}
public override void Visit(UsingNamespace un)
{
var ud = new UsingDeclaration();
var loc = LocationsBag.GetLocations(un);
ud.AddChild(new CSharpTokenNode(Convert(un.Location), UsingDeclaration.UsingKeywordRole), UsingDeclaration.UsingKeywordRole);
if (un.NamespaceExpression != null)
ud.AddChild(ConvertToType(un.NamespaceExpression), UsingDeclaration.ImportRole);
if (loc != null)
ud.AddChild(new CSharpTokenNode(Convert(loc [0]), Roles.Semicolon), Roles.Semicolon);
AddToNamespace(ud);
}
public override object VisitDeclareDeclaration(DeclareDeclaration declareDeclaration, object data)
{
if (usings != null && !usings.ContainsKey("System.Runtime.InteropServices")) {
UsingDeclaration @using = new UsingDeclaration("System.Runtime.InteropServices");
addedUsings.Add(@using);
base.VisitUsingDeclaration(@using, data);
}
MethodDeclaration method = new MethodDeclaration {
Name = declareDeclaration.Name,
Modifier = declareDeclaration.Modifier,
TypeReference = declareDeclaration.TypeReference,
Parameters = declareDeclaration.Parameters,
Attributes = declareDeclaration.Attributes
};
if ((method.Modifier & Modifiers.Visibility) == 0)
method.Modifier |= Modifiers.Public;
method.Modifier |= Modifiers.Extern | Modifiers.Static;
if (method.TypeReference.IsNull) {
method.TypeReference = new TypeReference("System.Void", true);
}
Attribute att = new Attribute("DllImport", null, null);
att.PositionalArguments.Add(CreateStringLiteral(declareDeclaration.Library));
if (declareDeclaration.Alias.Length > 0) {
att.NamedArguments.Add(new NamedArgumentExpression("EntryPoint", CreateStringLiteral(declareDeclaration.Alias)));
}
switch (declareDeclaration.Charset) {
case CharsetModifier.Auto:
att.NamedArguments.Add(new NamedArgumentExpression("CharSet",
new MemberReferenceExpression(new IdentifierExpression("CharSet"),
"Auto")));
break;
case CharsetModifier.Unicode:
att.NamedArguments.Add(new NamedArgumentExpression("CharSet",
new MemberReferenceExpression(new IdentifierExpression("CharSet"),
"Unicode")));
break;
default:
att.NamedArguments.Add(new NamedArgumentExpression("CharSet",
new MemberReferenceExpression(new IdentifierExpression("CharSet"),
"Ansi")));
break;
}
att.NamedArguments.Add(new NamedArgumentExpression("SetLastError", new PrimitiveExpression(true, true.ToString())));
att.NamedArguments.Add(new NamedArgumentExpression("ExactSpelling", new PrimitiveExpression(true, true.ToString())));
method.Attributes.Add(new AttributeSection { Attributes = { att } });
ReplaceCurrentNode(method);
return base.VisitMethodDeclaration(method, data);
}
public override void Visit (UsingsBag.Using u)
{
UsingDeclaration ud = new UsingDeclaration ();
ud.AddChild (new CSharpTokenNode (Convert (u.UsingLocation), "using".Length), UsingDeclaration.Roles.Keyword);
ud.AddChild (new Identifier (u.NSpace.Name, Convert (u.NSpace.Location)), UsingDeclaration.Roles.Identifier);
ud.AddChild (new CSharpTokenNode (Convert (u.SemicolonLocation), 1), UsingDeclaration.Roles.Semicolon);
AddToNamespace (ud);
}
public override void VisitUsingDeclaration(UsingDeclaration usingDeclaration)
{
imports.Add(usingDeclaration.GetText().Replace("using ", "").Replace(";\n", ""));
base.VisitUsingDeclaration (usingDeclaration);
}
public override object VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data)
{
foreach (Using u in usingDeclaration.Usings) {
namespaceDeclarations.Peek().Imports.Add(new CodeNamespaceImport(u.Name));
}
return null;
}
void ImportsStmt() {
#line 299 "VBNET.ATG"
List<Using> usings = new List<Using>();
Expect(124);
#line 303 "VBNET.ATG"
Location startPos = t.Location;
Using u;
ImportClause(
#line 306 "VBNET.ATG"
out u);
#line 306 "VBNET.ATG"
if (u != null) { usings.Add(u); }
while (la.kind == 12) {
lexer.NextToken();
ImportClause(
#line 308 "VBNET.ATG"
out u);
#line 308 "VBNET.ATG"
if (u != null) { usings.Add(u); }
}
EndOfStmt();
#line 312 "VBNET.ATG"
UsingDeclaration usingDeclaration = new UsingDeclaration(usings);
usingDeclaration.StartLocation = startPos;
usingDeclaration.EndLocation = t.Location;
compilationUnit.AddChild(usingDeclaration);
}
