public override void Visit(ISST sst, IList <Event> events)
{
foreach (var method in sst.Methods)
{
Visit(method, events);
}
}
public static CompletionExpressionCounter On(ISST sst)
{
var counter = new CompletionExpressionCounter();
sst.Accept(new HasCompletionExpressionVisitor(), counter);
return(counter);
}
public int Visit(ISST sst, int context)
{
var size = 1;
foreach (var e in sst.Events)
{
size += e.Accept(this, 0);
}
foreach (var f in sst.Fields)
{
size += f.Accept(this, 0);
}
foreach (var m in sst.Methods)
{
size += m.Accept(this, 0);
}
foreach (var p in sst.Properties)
{
size += p.Accept(this, 0);
}
return(size);
}
public IKaVEList <Query> Extract(ISST sst)
{
var queries = Lists.NewList <Query>();
foreach (var method in sst.Methods)
{
var context = new UsageContext
{
Enclosings =
{
Type = sst.EnclosingType,
Method = method.Name
}
};
AddDefaultQueries(sst, context);
Extract(method, context);
foreach (var query in context.AllQueries)
{
queries.Add(query);
}
}
return(queries);
}
private static bool IsGenerated(ISST td)
{
var partId = td.PartialClassIdentifier;
return(td.IsPartialClass && partId != null &&
(partId.Contains(".Designer") || partId.Contains(".designer")));
}
private ISet <IAssemblyName> FindAPIs(ISST sst)
{
var apis = new HashSet <IAssemblyName>();
sst.Accept(_apiVisitor, apis);
return(apis);
}
private static void AssertFormatting(string expected, ISST sst)
{
var sut = new XamlSSTPrintingContext();
sst.Accept(new SSTPrintingVisitor(), sut);
var actual = sut.ToString();
Assert.AreEqual(expected, actual);
}
public override void Visit(ISST sst, ITypeShape context)
{
if (IsGenerated(sst))
{
return;
}
_types[sst.EnclosingType] = 1;
base.Visit(sst, context);
}
private void AssertLinesInMethodBody(ISST sst, params string[] lines)
{
AssertFormatting(
"<Span Foreground=\"Blue\">class</Span> <Span Foreground=\"#2B91AF\">T</Span>" + Environment.NewLine +
"{" + Environment.NewLine +
" <Span Foreground=\"#2B91AF\">R</Span> M()" + Environment.NewLine +
" {" + Environment.NewLine +
" " + string.Join(Environment.NewLine + " ", lines) + Environment.NewLine +
" }" + Environment.NewLine +
"}",
sst);
}
private IKaVEMethodDecl GetClassInit(ISST sst)
{
if (_cinit == null)
{
_cinit = new MethodDeclaration
{
Name = Names.Method("static [p:void] [{0}]..cinit()", sst.EnclosingType.Identifier),
IsEntryPoint = false
};
sst.Methods.Add(_cinit);
}
return(_cinit);
}
public override void Visit(ISST sst, StringBuilder sb)
{
sb.Append("class ");
sb.Append(sst.EnclosingType.Name);
sb.Append(" {\n");
foreach (var e in sst.Events)
{
e.Accept(this, sb);
}
foreach (var f in sst.Fields)
{
f.Accept(this, sb);
}
sb.Append("}\n");
}
public RelativeEditLocation Analyze(ISST sst)
{
foreach (var md in sst.Methods)
{
var res = new RelativeEditLocation();
foreach (var stmt in md.Body)
{
stmt.Accept(_visitor, res);
}
if (res.HasEditLocation)
{
return(res);
}
}
return(new RelativeEditLocation());
}
public ISST Anonymize(ISST sst)
{
var delegates = sst.Delegates.Select(Anonymize);
var events = sst.Events.Select(Anonymize);
var fields = sst.Fields.Select(Anonymize);
var methods = sst.Methods.Select(Anonymize);
var properties = sst.Properties.Select(Anonymize);
return(new SST
{
EnclosingType = sst.EnclosingType.ToAnonymousName(),
PartialClassIdentifier = sst.PartialClassIdentifier.ToHash(),
Delegates = Sets.NewHashSetFrom(delegates),
Events = Sets.NewHashSetFrom(events),
Fields = Sets.NewHashSetFrom(fields),
Methods = Sets.NewHashSetFrom(methods),
Properties = Sets.NewHashSetFrom(properties)
});
}
private static void AddDefaultQueries(ISST sst, UsageContext context)
{
context.DefineVariable("this", sst.EnclosingType, DefinitionSites.CreateDefinitionByThis());
context.DefineVariable("base", sst.EnclosingType, DefinitionSites.CreateDefinitionByThis());
foreach (var field in sst.Fields)
{
var id = field.Name.Name;
var type = field.Name.ValueType;
var definition = DefinitionSites.CreateDefinitionByField(field.Name);
context.DefineVariable(id, type, definition);
}
foreach (var property in sst.Properties)
{
var id = property.Name.Name;
var type = property.Name.ValueType;
var definition = DefinitionSites.CreateDefinitionByField(Names.UnknownField);
context.DefineVariable(id, type, definition);
}
}
public bool ShouldProcessOrRegister(ISST td)
{
if (IsGenerated(td) && _genCodeSetting == GeneratedCode.Exclude)
{
return(false);
}
if (td.IsPartialClass)
{
return(true);
}
lock (_seenTypes)
{
if (_seenTypes.Contains(td.EnclosingType))
{
return(_dupeSetting == Duplication.Include);
}
_seenTypes.Add(td.EnclosingType);
return(true);
}
}
public static DocumentType GuessDocumentType(IDocumentName docName, ISST context)
{
if (docName.Language != "CSharp")
{
return(DocumentType.Undefined);
}
var finder = new NamespaceFinderVisitor(TestNamespaces);
var testWasFound = new ValueTypeWrapper <bool>(false);
finder.Visit(context, testWasFound);
if (testWasFound)
{
return(DocumentType.Test);
}
finder = new NamespaceFinderVisitor(TestFrameworkNamespaces);
var testFrameworkWasFound = new ValueTypeWrapper <bool>(false);
finder.Visit(context, testFrameworkWasFound);
if (testFrameworkWasFound)
{
return(DocumentType.TestFramework);
}
if (Path.GetFileNameWithoutExtension(docName.FileName).Contains("test", CompareOptions.IgnoreCase))
{
return(DocumentType.FilenameTest);
}
if (docName.FileName.Contains("test", CompareOptions.IgnoreCase))
{
return(DocumentType.PathnameTest);
}
return(DocumentType.Production);
}
public virtual void Visit(ISST sst, TContext context)
{
foreach (var d in sst.Delegates)
{
d.Accept(this, context);
}
foreach (var e in sst.Events)
{
e.Accept(this, context);
}
foreach (var f in sst.Fields)
{
f.Accept(this, context);
}
foreach (var m in sst.Methods)
{
m.Accept(this, context);
}
foreach (var p in sst.Properties)
{
p.Accept(this, context);
}
}
private int CountLoc(ISST sst)
{
return(sst.Accept(_locVisitor, 0));
}
private static bool IsGenerated(ISST td)
{
return(td.IsPartialClass && td.PartialClassIdentifier != null &&
(td.PartialClassIdentifier.Contains(".Designer") || td.PartialClassIdentifier.Contains(".designer")));
}
private static bool HasTriggerPoint(ISST sst)
{
var counter = HasCompletionExpressionVisitor.On(sst);
return(counter.HasCompletionExpression);
}
public void Visit(ISST sst, SSTPrintingContext c)
{
c.Indentation();
if (!string.IsNullOrEmpty(sst.PartialClassIdentifier))
{
c.Keyword("partial").Space();
}
if (sst.EnclosingType.IsInterfaceType)
{
c.Keyword("interface");
}
else if (sst.EnclosingType.IsEnumType)
{
c.Keyword("enum");
}
else if (sst.EnclosingType.IsStructType)
{
c.Keyword("struct");
}
else
{
c.Keyword("class");
}
c.Space().Type(sst.EnclosingType);
if (c.TypeShape != null && c.TypeShape.TypeHierarchy.HasSupertypes)
{
c.Text(" : ");
if (c.TypeShape.TypeHierarchy.HasSuperclass && c.TypeShape.TypeHierarchy.Extends != null)
{
c.Type(c.TypeShape.TypeHierarchy.Extends.Element);
if (c.TypeShape.TypeHierarchy.IsImplementingInterfaces)
{
c.Text(", ");
}
}
foreach (var i in c.TypeShape.TypeHierarchy.Implements)
{
c.Type(i.Element);
if (!ReferenceEquals(i, c.TypeShape.TypeHierarchy.Implements.Last()))
{
c.Text(", ");
}
}
}
c.NewLine()
.Indentation().Text("{").NewLine();
c.IndentationLevel++;
AppendMemberDeclarationGroup(c, sst.Delegates);
AppendMemberDeclarationGroup(c, sst.Events);
AppendMemberDeclarationGroup(c, sst.Fields);
AppendMemberDeclarationGroup(c, sst.Properties);
AppendMemberDeclarationGroup(c, sst.Methods, 2, 1);
c.IndentationLevel--;
c.Indentation().Text("}");
}
