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("}"); }