public static List <MethodDeclarationSyntax> SearchForMethod(this ClassDeclarationSyntax classDeclaration,
MethodMatch methodMatch)
{
if (Program.Debug)
{
Program.WriteLine(ConsoleColor.Yellow, $"Trying to find {{{UsingDirective.BuildFullMemberTag(methodMatch)}}}");
Program.IndentLevel++;
}
List <MethodDeclarationSyntax> s = Registry.GetMatchedMember(methodMatch);
if (!Program.SkipOne)
{
Program.WriteLine(ConsoleColor.Red, "Skipping for speed");
s = classDeclaration.Members.OfType <MethodDeclarationSyntax>().Where(methodMatch.Matches)
.ToList();
}
if (Program.Debug)
{
Program.IndentLevel--;
}
return(s);
}
public static List <EnumDeclarationSyntax> SearchForEnum(EnumMatch enumMatch)
{
if (Program.Debug)
{
Program.WriteLine(ConsoleColor.Yellow, $"Trying to find {{{UsingDirective.BuildFullTypeTag(enumMatch)}}}");
Program.IndentLevel++;
}
List <EnumDeclarationSyntax> ls = Registry.GetMatchedType(enumMatch);
if (!Program.SkipOne)
{
ls = Registry.AssemblyCs.Values.Where(c => c is EnumDeclarationSyntax e && enumMatch.Matches(e))
.Cast <EnumDeclarationSyntax>().ToList();
}
foreach (var enumDeclarationSyntax in ls)
{
Registry.AddMatchedType(enumMatch, enumDeclarationSyntax);
}
if (Program.Debug)
{
Program.IndentLevel--;
}
return(ls);
}
protected override async Task <UsingDirective> AssignUpsertedReferences(UsingDirective record)
{
record.Identifier = await _identifiers.UpsertAsync(record.Identifier);
record.IdentifierId = record.Identifier?.IdentifierId ?? record.IdentifierId;
return(record);
}
public void AddUsing(UsingDirective u)
{
this.FileUsings.Add(u);
this.namespaceSearchPrefixes = null;
bool isLinq = string.Join('.', u.Path.Select(token => token.Value)) == "System.Linq";
this.HasLinq = this.HasLinq || isLinq;
}
public void CSharpCodeGenerator_UsingDirective()
{
var directive = new UsingDirective("System");
var generator = new CSharpCodeGenerator();
var result = generator.Write(directive);
Assert.That.StringEquals("using System;", result);
}
/// <summary>
/// Compares the order of two using directives.
/// </summary>
/// <param name="firstUsing">The first using directive.</param>
/// <param name="secondUsing">The second using directive.</param>
/// <returns>Returns false if the elements are out of order.</returns>
private bool CompareOrderOfUsingDirectives(UsingDirective firstUsing, UsingDirective secondUsing)
{
Param.AssertNotNull(firstUsing, "firstUsing");
Param.AssertNotNull(secondUsing, "secondUsing");
if (string.IsNullOrEmpty(firstUsing.Alias))
{
if (string.IsNullOrEmpty(secondUsing.Alias))
{
bool isFirstSystem = firstUsing.NamespaceType.StartsWith("System", StringComparison.Ordinal) || firstUsing.NamespaceType.StartsWith("System.", StringComparison.Ordinal);
bool isSecondSystem = secondUsing.NamespaceType.Equals("System", StringComparison.Ordinal) || secondUsing.NamespaceType.StartsWith("System.", StringComparison.Ordinal);
// Neither of the usings is an alias. First, ensure that System namespaces are placed above all
// non-System namespaces.
if (isSecondSystem && !isFirstSystem)
{
this.AddViolation(secondUsing, Rules.SystemUsingDirectivesMustBePlacedBeforeOtherUsingDirectives);
return(false);
}
else if ((isFirstSystem && isSecondSystem) || (!isFirstSystem && !isSecondSystem))
{
if (!CheckNamespaceOrdering(firstUsing.NamespaceType, secondUsing.NamespaceType))
{
// The usings are not in alphabetical order by namespace.
this.AddViolation(firstUsing, Rules.UsingDirectivesMustBeOrderedAlphabeticallyByNamespace);
return(false);
}
}
}
}
else
{
if (string.IsNullOrEmpty(secondUsing.Alias))
{
// The first using is an alias, but the second is not. They are in the wrong order.
this.AddViolation(firstUsing, Rules.UsingAliasDirectivesMustBePlacedAfterOtherUsingDirectives);
return(false);
}
else
{
// Both of the usings are aliases. Verify that they are sorted alphabetically by the alias name.
if (string.Compare(firstUsing.Alias, secondUsing.Alias, StringComparison.OrdinalIgnoreCase) > 0)
{
// The usings are not sorted alphabetically by the alias.
this.AddViolation(firstUsing, Rules.UsingAliasDirectivesMustBeOrderedAlphabeticallyByAliasName);
return(false);
}
}
}
return(true);
}
/// <summary>
/// Adds a new using directive with the specified namespace.
///
/// <param name="ns">reference to namespace</param>
/// </summary>
public void add_using_directive(UsingDirective ns)
{
// do not modify current_using_directives, it should be considered immutable
// for correct symbol resolving
var old_using_directives = current_using_directives;
current_using_directives = new List <UsingDirective>();
foreach (var using_directive in old_using_directives)
{
current_using_directives.Add(using_directive);
}
current_using_directives.Add(ns);
}
public void ReturnsNull()
{
var d1 = new UsingDirective {
Namespace = "System"
};
var d2 = new UsingDirective {
Namespace = "System.Linq"
};
var required = new[] { d1, d2 };
var current = new[] { d1, d2 };
Assert.IsNull(OrderChecker.GetNextUsingToMove(required, current));
}
private void Add(UsingBlock usingSection, UsingDirective usingEntry)
{
if (usingSection.VMembers.Children.Count == 1 &&
usingSection.FirstUsing != null &&
usingSection.FirstUsing.Text == "")
{
usingSection.VMembers.Children.Replace(usingSection.FirstUsing, usingEntry);
}
else
{
usingSection.VMembers.Children.Add(usingEntry);
}
}
public static UstNode GetObject(string type)
{
UstNode ustNode = null;
switch (type)
{
case IdConstants.RootIdName:
ustNode = new RootUstNode();
break;
case IdConstants.UsingDirectiveIdName:
ustNode = new UsingDirective();
break;
case IdConstants.NamespaceIdName:
ustNode = new NamespaceDeclaration();
break;
case IdConstants.ClassIdName:
ustNode = new ClassDeclaration();
break;
case IdConstants.InterfaceIdName:
ustNode = new InterfaceDeclaration();
break;
case IdConstants.BodyIdName:
ustNode = new BlockStatement();
break;
case IdConstants.ObjectCreationIdName:
ustNode = new ObjectCreationExpression();
break;
case IdConstants.InvocationIdName:
ustNode = new InvocationExpression();
break;
case IdConstants.LiteralIdName:
ustNode = new LiteralExpression();
break;
case IdConstants.MethodIdName:
ustNode = new MethodDeclaration();
break;
default: break;
}
return(ustNode);
}
public static List <ClassDeclarationSyntax> SearchForClass(ClassMatch classMatch)
{
if (Program.Debug)
{
Program.WriteLine(ConsoleColor.Yellow, $"Trying to find {{{UsingDirective.BuildFullTypeTag(classMatch)}}}");
Program.IndentLevel++;
}
List <ClassDeclarationSyntax> ls = Registry.GetMatchedType(classMatch);
if (!Program.SkipOne)
{
ls = Registry.AssemblyCs.Values.Where(c => c is ClassDeclarationSyntax cl && classMatch.Matches(cl))
.Cast <ClassDeclarationSyntax>().ToList();
}
List <ClassDeclarationSyntax> toRemove = new();
foreach (var classDeclarationSyntax in ls)
{
if (Registry.Fullmatches.Contains(classDeclarationSyntax))
{
toRemove.Add(classDeclarationSyntax);
}
else
{
Registry.AddMatchedType(classMatch, classDeclarationSyntax);
}
}
foreach (var torm in toRemove)
{
ls.Remove(torm);
}
if (ls.Count == 1)
{
Registry.Fullmatches.Add(ls[0]);
}
if (Program.Debug)
{
Program.IndentLevel--;
}
return(ls);
}
public override void visit_using_directive(UsingDirective ns)
{
var unresolved_symbol = ns.namespace_symbol as UnresolvedSymbol;
if (unresolved_symbol != null)
{
ns.namespace_symbol = resolve_symbol(unresolved_symbol);
if (!(ns.namespace_symbol is Namespace))
{
ns.error = true;
Report.error(ns.source_reference, "The namespace name `%s' could not be found".printf(unresolved_symbol.ToString()));
return;
}
}
}
/// <summary>
/// Checks the order of the using directives in the given list.
/// </summary>
/// <param name="usings">The list of using directives.</param>
private void CheckOrderOfUsingDirectivesInList(List <UsingDirective> usings)
{
Param.AssertNotNull(usings, "usings");
for (int i = 0; i < usings.Count; ++i)
{
UsingDirective firstUsing = usings[i];
for (int j = i + 1; j < usings.Count; ++j)
{
UsingDirective secondUsing = usings[j];
if (!this.CompareOrderOfUsingDirectives(firstUsing, secondUsing))
{
break;
}
}
}
}
internal void Verify(UsingDirective[] directivesIn, params UsingDirective[][] expectedGroups)
{
foreach (var permutation in AllOrderings(directivesIn))
{
var results = OrderAndSpacingGenerator.DetermineOrderAndSpacing(
permutation, Configuration);
Assert.AreEqual(expectedGroups.Length, results.Count);
for (int i = 0; i < expectedGroups.Length; ++i)
{
Assert.AreEqual(results[i].Count, expectedGroups[i].Length, "Item count in group " + i);
for (int j = 0; j < expectedGroups[i].Length; ++j)
{
UsingDirective expectedUsing = expectedGroups[i][j];
UsingDirective actualUsing = results[i][j];
string message = string.Format(
"Expected {0} at {1},{2}, found {3}", expectedUsing, i, j, actualUsing);
Assert.AreSame(expectedUsing, actualUsing, message);
}
}
}
}
public static List <EnumMemberDeclarationSyntax> SearchForEnumValue(this EnumDeclarationSyntax enumDeclaration,
EnumValueMatch valueMatch)
{
if (Program.Debug)
{
Program.WriteLine(ConsoleColor.Yellow, $"Trying to find {{{UsingDirective.BuildFullMemberTag(valueMatch)}}}");
Program.IndentLevel++;
}
List <EnumMemberDeclarationSyntax> s = Registry.GetMatchedMember(valueMatch);
if (!Program.SkipOne)
{
s = enumDeclaration.Members.Where(m => valueMatch.Matches(m))
.ToList();
}
if (Program.Debug)
{
Program.IndentLevel--;
}
return(s);
}
public static List <FieldDeclarationSyntax> SearchForField(this ClassDeclarationSyntax type, FieldMatch fieldMatch)
{
if (Program.Debug)
{
Program.WriteLine(ConsoleColor.Yellow, $"Trying to find {{{UsingDirective.BuildFullMemberTag(fieldMatch)}}}");
Program.IndentLevel++;
}
List <FieldDeclarationSyntax> s = Registry.GetMatchedMember(fieldMatch);
if (!Program.SkipOne)
{
s = type.Members.OfType <FieldDeclarationSyntax>().Where(fieldMatch.Matches)
.ToList();
}
if (Program.Debug)
{
Program.IndentLevel--;
}
return(s);
}
internal static void using_directive_location(this TextWriter trapFile, UsingDirective @using, Location location)
{
trapFile.WriteTuple("using_directive_location", @using, location);
}
internal static void using_namespace_directives(this TextWriter trapFile, UsingDirective @using, Namespace ns)
{
trapFile.WriteTuple("using_namespace_directives", @using, ns);
}
protected override Expression <Func <UsingDirective, bool> > FindExisting(UsingDirective record) => existing => existing.IdentifierId == record.IdentifierId;
protected override IEnumerable <object> EnumerateReferences(UsingDirective record)
{
yield return(record.Identifier);
}
private void Process_Using_Directive(UsingDirective node)
{
if (node == null) throw new ArgumentNullException("node");
UsingStatement usingDirective = new UsingStatement(controller);
usingDirective.Alias = node.Alias ?? "";
usingDirective.Value = node.NamespaceName.Text;
SetupBaseConstruct(node.StartOffset, node.EndOffset, "", usingDirective, null);
}
internal static Tuple using_static_directives(UsingDirective @using, Type type) => new Tuple("using_static_directives", @using, type);
public AliasAndUsingDirective(AliasSymbol alias, UsingDirective usingDirective)
{
this.Alias = alias;
this.UsingDirective = usingDirective;
}
internal static Tuple using_namespace_directives(UsingDirective @using, Namespace ns) => new Tuple("using_namespace_directives", @using, ns);
private void MarkImportDirective(UsingDirective directive, bool callerIsSemanticModel)
{
MarkImportDirective(_compilation, directive.SyntaxNode, callerIsSemanticModel);
}
public NamespaceOrTypeAndUsingDirective(NamespaceOrTypeSymbol namespaceOrType, UsingDirective usingDirective)
{
this.NamespaceOrType = namespaceOrType;
this.UsingDirective = usingDirective;
}
//-----------------------------------------------------------------------------
// Parse and return an array of using declarations
// ** rules **
// UsingDirective -> 'using' id:name '=' id_list ';' // for aliasing
// UsingDirective -> 'using' id_list ';' // for namespaces
//-----------------------------------------------------------------------------
protected UsingDirective[] ParseUsingDirectives()
{
Token t;
t = m_lexer.PeekNextToken();
ArrayList a = new ArrayList();
while( t.TokenType == Token.Type.cUsing)
{
ConsumeNextToken();
Exp o = ParseDottedIdList();
UsingDirective node;
FileRange f = this.BeginRange();
t = m_lexer.PeekNextToken();
if (t.TokenType == Token.Type.cAssign)
{
ConsumeNextToken();
// o had better be a single identifier
SimpleObjExp s = o as SimpleObjExp;
Debug.Assert(s != null);
string stAlias = s.Name.Text;
Exp o2 = ParseDottedIdList();
node = new UsingDirective(stAlias, o2);
}
else
{
node = new UsingDirective(o);
}
ReadExpectedToken(Token.Type.cSemi);
Debug.Assert(node != null);
node.SetLocation(this.EndRange(f));
a.Add(node);
t = m_lexer.PeekNextToken();
}
UsingDirective[] arNodes = (UsingDirective[]) a.ToArray(typeof(UsingDirective));
return arNodes;
}
internal static void using_static_directives(this TextWriter trapFile, UsingDirective @using, Type type)
{
trapFile.WriteTuple("using_static_directives", @using, type);
}
internal static Tuple using_directive_location(UsingDirective @using, Location location) => new Tuple("using_directive_location", @using, location);
public void TestCaseEvaluation1()
{
var directive = new UsingDirective("BOO ? TO $", "BEER", TypeConverter);
Assert.AreEqual("1", Evaluate("{BOO I TO 1}{I}{BEER}", directive));
}
public void TestCaseConstructor3()
{
var directive = new UsingDirective("SET $ TO BE ?", "TERMINATE", TypeConverter);
Assert.AreEqual("{SET $ TO BE ?}...{TERMINATE}", directive.ToString());
}
private bool Equals(UsingDirective other)
{
return(Name == other.Name && Alias == other.Alias);
}
private void Add(UsingBlock usingSection, UsingDirective usingEntry)
{
if (usingSection.VMembers.Children.Count == 1
&& usingSection.FirstUsing != null
&& usingSection.FirstUsing.Text == "")
{
usingSection.VMembers.Children.Replace(usingSection.FirstUsing, usingEntry);
}
else
{
usingSection.VMembers.Children.Add(usingEntry);
}
}
