public CodeGenerationOptions()
{
currentState = new Lazy <CSharpResolver> (() => {
var parsedDocument = Document.ParsedDocument;
if (parsedDocument == null)
{
return(null);
}
var unit = parsedDocument.GetAst <SyntaxTree> ().Clone();
var file = parsedDocument.ParsedFile as CSharpUnresolvedFile;
var resolvedNode = unit.GetNodeAt <BlockStatement> (Document.Editor.Caret.Location);
if (resolvedNode == null)
{
return(null);
}
var expr = new IdentifierExpression("foo");
resolvedNode.Add(expr);
var ctx = file.GetTypeResolveContext(Document.Compilation, Document.Editor.Caret.Location);
var resolver = new CSharpResolver(ctx);
var astResolver = new CSharpAstResolver(resolver, unit, file);
astResolver.ApplyNavigator(new NodeListResolveVisitorNavigator(expr), CancellationToken.None);
astResolver.Resolve(expr);
return(astResolver.GetResolverStateBefore(expr));
});
}
public SemanticErrorsResponse FindSemanticErrors(Request request)
{
var clientFilename = request.FileName.ApplyPathReplacementsForClient();
var project = _solution.ProjectContainingFile(request.FileName);
project.UpdateFile(request.FileName, request.Buffer);
var solutionSnapshot = new DefaultSolutionSnapshot(_solution.Projects.Select(i => i.ProjectContent));
var syntaxTree = new CSharpParser().Parse(request.Buffer, request.FileName);
var resolver = new CSharpAstResolver(solutionSnapshot.GetCompilation(project.ProjectContent), syntaxTree);
var navigator = new SemanticErrorsNavigator();
resolver.ApplyNavigator(navigator);
var errors = navigator.GetErrors().Select(i => new Error
{
FileName = clientFilename,
Message = i.Message,
Line = i.TextLocation.Line,
Column = i.TextLocation.Column,
});
return(new SemanticErrorsResponse
{
Errors = errors,
});
}
// Token: 0x06000012 RID: 18 RVA: 0x0000243C File Offset: 0x0000063C
private ResolveResult GetLanguageItem(ProjectDocument doc, string expression, Client.SourceLocation location)
{
ParsedDocument parsedDocument = doc.ParsedDocument;
if (parsedDocument == null)
{
return(null);
}
SyntaxTree ast = parsedDocument.GetAst <SyntaxTree>();
CSharpUnresolvedFile csharpUnresolvedFile = parsedDocument.ParsedFile as CSharpUnresolvedFile;
if (ast == null || csharpUnresolvedFile == null)
{
return(null);
}
AstNode nodeAt = ast.GetNodeAt(location.Line, location.Column, null);
if (nodeAt == null)
{
return(null);
}
CSharpTypeResolveContext typeResolveContext = csharpUnresolvedFile.GetTypeResolveContext(doc.Compilation, new TextLocation(location.Line, location.Column));
CSharpResolver resolver = new CSharpResolver(typeResolveContext);
CSharpAstResolver csharpAstResolver = new CSharpAstResolver(resolver, ast, csharpUnresolvedFile);
csharpAstResolver.ApplyNavigator(new NodeListResolveVisitorNavigator(new AstNode[]
{
nodeAt
}), CancellationToken.None);
CSharpResolver resolverStateBefore = csharpAstResolver.GetResolverStateBefore(nodeAt, CancellationToken.None);
return(resolverStateBefore.LookupSimpleNameOrTypeName(expression, new List <IType>(), NameLookupMode.Expression));
}
void ResolveButtonClick(object sender, EventArgs e)
{
IProjectContent project = new CSharpProjectContent();
var parsedFile = compilationUnit.ToTypeSystem();
project = project.UpdateProjectContent(null, parsedFile);
project = project.AddAssemblyReferences(builtInLibs.Value);
ICompilation compilation = project.CreateCompilation();
StoreInDictionaryNavigator navigator;
if (csharpTreeView.SelectedNode != null)
{
navigator = new StoreInDictionaryNavigator((AstNode)csharpTreeView.SelectedNode.Tag);
}
else
{
navigator = new StoreInDictionaryNavigator();
}
CSharpAstResolver resolver = new CSharpAstResolver(compilation, compilationUnit, parsedFile);
resolver.ApplyNavigator(navigator);
csharpTreeView.BeginUpdate();
ShowResolveResultsInTree(csharpTreeView.Nodes, navigator);
csharpTreeView.EndUpdate();
}
void AnalyzeFile(ProjectFile file, IProjectContent content)
{
var me = new object();
var owner = processedFiles.AddOrUpdate(file.Name, me, (key, old) => old);
if (me != owner)
{
return;
}
if (file.BuildAction != BuildAction.Compile || tokenSource.IsCancellationRequested)
{
return;
}
TextEditorData editor;
try {
editor = TextFileProvider.Instance.GetReadOnlyTextEditorData(file.FilePath);
} catch (FileNotFoundException) {
// Swallow exception and ignore this file
return;
}
var document = TypeSystemService.ParseFile(file.Project, editor);
if (document == null)
{
return;
}
var compilation = content.AddOrUpdateFiles(document.ParsedFile).CreateCompilation();
CSharpAstResolver resolver;
using (var timer = ExtensionMethods.ResolveCounter.BeginTiming()) {
resolver = new CSharpAstResolver(compilation, document.GetAst <SyntaxTree> (), document.ParsedFile as ICSharpCode.NRefactory.CSharp.TypeSystem.CSharpUnresolvedFile);
resolver.ApplyNavigator(new ExtensionMethods.ConstantModeResolveVisitorNavigator(ResolveVisitorNavigationMode.Resolve, null));
}
var context = document.CreateRefactoringContextWithEditor(editor, resolver, tokenSource.Token);
CodeIssueProvider[] codeIssueProvider = RefactoringService.GetInspectors(editor.MimeType).ToArray();
foreach (var provider in codeIssueProvider)
{
var severity = provider.GetSeverity();
if (severity == Severity.None || tokenSource.IsCancellationRequested)
{
return;
}
try {
foreach (var issue in provider.GetIssues(context, tokenSource.Token))
{
AddIssue(file, provider, issue);
}
} catch (OperationCanceledException) {
// The operation was cancelled, no-op as the user-visible parts are
// handled elsewhere
}
}
}
public static void RunTest(CSharpFile file)
{
CSharpAstResolver resolver = new CSharpAstResolver(file.Project.Compilation, file.SyntaxTree, file.UnresolvedTypeSystemForFile);
var navigator = new ValidatingResolveAllNavigator(file.FileName);
resolver.ApplyNavigator(navigator, CancellationToken.None);
navigator.Validate(resolver, file.SyntaxTree);
}
public static void RunTest(CSharpFile file)
{
CSharpAstResolver resolver = new CSharpAstResolver(file.Project.Compilation, file.CompilationUnit, file.ParsedFile);
var navigator = new ValidatingResolveAllNavigator(file.FileName);
resolver.ApplyNavigator(navigator, CancellationToken.None);
navigator.Validate(file.CompilationUnit);
}
/// <summary>
/// Returns a full C# syntax tree resolver which is shared between semantic highlighting, source analysis and refactoring.
/// For code analysis tasks this should be used instead of generating an own resolver. Only exception is if a local resolving is done using a
/// resolve navigator.
/// Note: The shared resolver is fully resolved.
/// </summary>
public static TaskWrapper GetSharedResolver(this Document document)
{
var parsedDocument = document.ParsedDocument;
if (parsedDocument == null || document.IsProjectContextInUpdate)
{
return(null);
}
var unit = parsedDocument.GetAst <SyntaxTree> ();
var parsedFile = parsedDocument.ParsedFile as CSharpUnresolvedFile;
if (unit == null || parsedFile == null)
{
return(null);
}
var compilation = document.Compilation;
var resolverAnnotation = document.Annotation <ResolverAnnotation> ();
if (resolverAnnotation != null)
{
if (resolverAnnotation.ParsedFile == parsedFile)
{
return(resolverAnnotation.Task);
}
if (resolverAnnotation.SharedTokenSource != null)
{
resolverAnnotation.SharedTokenSource.Cancel();
}
document.RemoveAnnotations <ResolverAnnotation> ();
}
var tokenSource = new CancellationTokenSource();
var token = tokenSource.Token;
var resolveTask = Task.Factory.StartNew(delegate {
try {
using (var timer = ResolveCounter.BeginTiming()) {
var result = new CSharpAstResolver(compilation, unit, parsedFile);
result.ApplyNavigator(new ConstantModeResolveVisitorNavigator(ResolveVisitorNavigationMode.Resolve, null), token);
return(result);
}
} catch (OperationCanceledException) {
return(null);
} catch (Exception e) {
LoggingService.LogError("Error while creating the resolver.", e);
return(null);
}
}, token);
var wrapper = new TaskWrapper(resolveTask);
document.AddAnnotation(new ResolverAnnotation {
Task = wrapper,
ParsedFile = parsedFile,
SharedTokenSource = tokenSource
});
return(wrapper);
}
public static bool TypeChangeResolvesCorrectly(BaseRefactoringContext ctx, ParameterDeclaration parameter, AstNode rootNode, IType type)
{
var resolver = ctx.GetResolverStateBefore(rootNode);
resolver = resolver.AddVariable(new DefaultParameter(type, parameter.Name));
var astResolver = new CSharpAstResolver(resolver, rootNode, ctx.UnresolvedFile);
var validator = new TypeChangeValidationNavigator();
astResolver.ApplyNavigator(validator, ctx.CancellationToken);
return(!validator.FoundErrors);
}
public override TooltipItem GetItem(Mono.TextEditor.TextEditor editor, int offset)
{
var doc = IdeApp.Workbench.ActiveDocument;
if (doc == null || doc.ParsedDocument == null)
{
return(null);
}
var unit = doc.ParsedDocument.GetAst <SyntaxTree> ();
if (unit == null)
{
return(null);
}
var file = doc.ParsedDocument.ParsedFile as CSharpUnresolvedFile;
if (file == null)
{
return(null);
}
ResolveResult result;
AstNode node;
var loc = editor.OffsetToLocation(offset);
if (!doc.TryResolveAt(loc, out result, out node))
{
if (node is CSharpTokenNode)
{
int startOffset2 = editor.LocationToOffset(node.StartLocation);
int endOffset2 = editor.LocationToOffset(node.EndLocation);
return(new TooltipItem(new ToolTipData(unit, result, node, null), startOffset2, endOffset2 - startOffset2));
}
return(null);
}
if (node == lastNode)
{
return(lastResult);
}
var resolver = new CSharpAstResolver(doc.Compilation, unit, file);
resolver.ApplyNavigator(new NodeListResolveVisitorNavigator(node), CancellationToken.None);
var hoverNode = node.GetNodeAt(loc) ?? node;
int startOffset = editor.LocationToOffset(hoverNode.StartLocation);
int endOffset = editor.LocationToOffset(hoverNode.EndLocation);
return(lastResult = new TooltipItem(new ToolTipData(unit, result, node, resolver), startOffset, endOffset - startOffset));
}
public void Run()
{
using (new Timer("Finding referenced entities... ")) {
foreach (var file in solution.AllFiles)
{
var navigator = new FindReferencedEntities(
delegate(AstNode node, IEntity entity) {
if (node == null)
{
throw new ArgumentNullException("node");
}
if (entity == null)
{
throw new ArgumentNullException("entity");
}
if (!IgnoreEntity(entity))
{
HashSet <AstNode> list;
if (!referenceDict.TryGetValue(entity, out list))
{
list = new HashSet <AstNode>();
referenceDict.Add(entity, list);
}
list.Add(node);
}
}
);
var resolver = new CSharpAstResolver(file.Project.Compilation, file.CompilationUnit, file.ParsedFile);
resolver.ApplyNavigator(navigator);
}
}
Console.WriteLine("For each entity, find all references...");
Stopwatch w = Stopwatch.StartNew();
foreach (var project in solution.Projects)
{
foreach (var type in project.Compilation.MainAssembly.GetAllTypeDefinitions())
{
TestFindReferences(type);
foreach (IMember m in type.Members)
{
TestFindReferences(m);
}
Console.Write('.');
}
}
w.Stop();
Console.WriteLine("FindReferencesConsistencyCheck is done ({0}).", w.Elapsed);
PrintTimingsPerEntityType();
}
public ResolveResult GetLanguageItem(MonoDevelop.Ide.Gui.Document doc, int offset, string expression)
{
if (offset < 0)
{
return(null);
}
var parsedDocument = doc.ParsedDocument;
if (parsedDocument == null)
{
return(null);
}
var data = doc.Editor;
var loc = data.OffsetToLocation(offset);
var unit = parsedDocument.GetAst <SyntaxTree> ();
var parsedFile = parsedDocument.ParsedFile as CSharpUnresolvedFile;
if (unit == null || parsedFile == null)
{
return(null);
}
var node = unit.GetNodeAt(loc);
if (node == null)
{
return(null);
}
var resolver = new CSharpAstResolver(doc.Compilation, unit, parsedFile);
resolver.ApplyNavigator(new NodeListResolveVisitorNavigator(node), CancellationToken.None);
var state = resolver.GetResolverStateBefore(node, CancellationToken.None);
var list = new List <IType> ();
int indexOf = expression.IndexOf('`');
if (indexOf != -1)
{
var intType = new PrimitiveType("int").ToTypeReference().Resolve(doc.Compilation);
var num = expression.Substring(indexOf + 1);
int number = int.Parse(num);
for (int i = 0; i < number; i++)
{
list.Add(intType);
}
expression = expression.Remove(indexOf);
}
return(state.LookupSimpleNameOrTypeName(expression, list, NameLookupMode.Expression));
}
public static void RunTestWithoutUnresolvedFile(CSharpFile file)
{
CSharpAstResolver resolver = new CSharpAstResolver(file.Project.Compilation, file.SyntaxTree);
var navigator = new ValidatingResolveAllNavigator(file.FileName);
resolver.ApplyNavigator(navigator, CancellationToken.None);
navigator.Validate(resolver, file.SyntaxTree);
CSharpAstResolver originalResolver = new CSharpAstResolver(file.Project.Compilation, file.SyntaxTree, file.UnresolvedTypeSystemForFile);
foreach (var node in file.SyntaxTree.DescendantsAndSelf)
{
var originalResult = originalResolver.Resolve(node);
var result = resolver.Resolve(node);
if (!RandomizedOrderResolverTest.IsEqualResolveResult(result, originalResult))
{
Console.WriteLine("Got different without IUnresolvedFile at " + file.FileName + ":" + node.StartLocation);
}
}
}
/// <summary>
/// Returns a full C# syntax tree resolver which is shared between semantic highlighting, source analysis and refactoring.
/// For code analysis tasks this should be used instead of generating an own resolver. Only exception is if a local resolving is done using a
/// resolve navigator.
/// Note: The shared resolver is fully resolved.
/// </summary>
public static Task <CSharpAstResolver> GetSharedResolver(this Document document)
{
var parsedDocument = document.ParsedDocument;
if (parsedDocument == null)
{
return(null);
}
var unit = parsedDocument.GetAst <SyntaxTree> ();
var parsedFile = parsedDocument.ParsedFile as CSharpUnresolvedFile;
if (unit == null || parsedFile == null)
{
return(null);
}
var compilation = document.Compilation;
var resolverAnnotation = document.Annotation <ResolverAnnotation> ();
if (resolverAnnotation != null)
{
if (resolverAnnotation.ParsedFile == parsedFile)
{
return(resolverAnnotation.Task);
}
document.RemoveAnnotations <ResolverAnnotation> ();
}
var resolveTask = Task.Factory.StartNew(delegate {
var result = new CSharpAstResolver(compilation, unit, parsedFile);
result.ApplyNavigator(new ConstantModeResolveVisitorNavigator(ResolveVisitorNavigationMode.Resolve, null));
return(result);
});
document.AddAnnotation(new ResolverAnnotation {
Task = resolveTask,
ParsedFile = parsedFile
});
return(resolveTask);
}
public TooltipItem GetItem(Mono.TextEditor.TextEditor editor, int offset)
{
var doc = IdeApp.Workbench.ActiveDocument;
if (doc == null || doc.ParsedDocument == null)
{
return(null);
}
var unit = doc.ParsedDocument.GetAst <CompilationUnit> ();
if (unit == null)
{
return(null);
}
var file = doc.ParsedDocument.ParsedFile as CSharpParsedFile;
if (file == null)
{
return(null);
}
ResolveResult result;
AstNode node;
var loc = editor.OffsetToLocation(offset);
if (!doc.TryResolveAt(loc, out result, out node))
{
return(null);
}
var resolver = new CSharpAstResolver(doc.Compilation, unit, file);
resolver.ApplyNavigator(new NodeListResolveVisitorNavigator(node), CancellationToken.None);
int startOffset = offset;
int endOffset = offset;
return(new TooltipItem(new ToolTipData(unit, result, node, resolver), startOffset, endOffset - startOffset));
}
public SemanticErrorsResponse FindSemanticErrors(Request request)
{
var clientFilename = request.FileName.ApplyPathReplacementsForClient();
var project = _solution.ProjectContainingFile(request.FileName);
project.UpdateFile(request.FileName, request.Buffer);
var solutionSnapshot = new DefaultSolutionSnapshot(_solution.Projects.Select(i => i.ProjectContent));
SyntaxTree syntaxTree;
if (project.CompilerSettings != null)
{
syntaxTree = new CSharpParser(project.CompilerSettings).Parse(request.Buffer, request.FileName);
}
else
{
syntaxTree = new CSharpParser().Parse(request.Buffer, request.FileName);
}
var resolver = new CSharpAstResolver(solutionSnapshot.GetCompilation(project.ProjectContent), syntaxTree);
var navigator = new SemanticErrorsNavigator();
resolver.ApplyNavigator(navigator);
var errors = navigator.GetErrors()
.Where(e => ShouldIncludeIssue(e.Message))
.Select(i => new Error
{
FileName = clientFilename,
Message = i.Message,
Line = i.StartLocation.Line,
Column = i.EndLocation.Column,
EndLine = i.EndLocation.Line,
EndColumn = i.EndLocation.Column
});
return(new SemanticErrorsResponse
{
Errors = errors,
});
}
public ResolveResult GetLanguageItem(MonoDevelop.Ide.Gui.Document doc, int offset, string expression)
{
if (offset < 0)
{
return(null);
}
var parsedDocument = doc.ParsedDocument;
if (parsedDocument == null)
{
return(null);
}
var data = doc.Editor;
var loc = data.OffsetToLocation(offset);
var unit = parsedDocument.GetAst <SyntaxTree> ();
var parsedFile = parsedDocument.ParsedFile as CSharpUnresolvedFile;
if (unit == null || parsedFile == null)
{
return(null);
}
var node = unit.GetNodeAt(loc);
if (node == null)
{
return(null);
}
var resolver = new CSharpAstResolver(doc.Compilation, unit, parsedFile);
resolver.ApplyNavigator(new NodeListResolveVisitorNavigator(node), CancellationToken.None);
var state = resolver.GetResolverStateBefore(node, CancellationToken.None);
return(state.LookupSimpleNameOrTypeName(expression, new List <IType> (), NameLookupMode.Expression));
}
/// <summary>
/// Returns a full C# syntax tree resolver which is shared between semantic highlighting, source analysis and refactoring.
/// For code analysis tasks this should be used instead of generating an own resolver. Only exception is if a local resolving is done using a
/// resolve navigator.
/// Note: The shared resolver is fully resolved.
/// </summary>
public static Task <CSharpAstResolver> GetSharedResolver(this Document document)
{
var parsedDocument = document.ParsedDocument;
if (parsedDocument == null || document.IsProjectContextInUpdate || document.Project != null && !(document.Project is DotNetProject))
{
return(null);
}
var unit = parsedDocument.GetAst <SyntaxTree> ();
var parsedFile = parsedDocument.ParsedFile as CSharpUnresolvedFile;
if (unit == null || parsedFile == null)
{
return(null);
}
var compilation = document.Compilation;
var resolverAnnotation = document.Annotation <ResolverAnnotation> ();
if (resolverAnnotation != null)
{
if (resolverAnnotation.ParsedFile == parsedFile)
{
return(resolverAnnotation.Task);
}
if (resolverAnnotation.SharedTokenSource != null)
{
resolverAnnotation.SharedTokenSource.Cancel();
}
document.RemoveAnnotations <ResolverAnnotation> ();
}
var tokenSource = new CancellationTokenSource();
var token = tokenSource.Token;
var resolveTask = Task.Factory.StartNew(delegate {
try {
using (var timer = ResolveCounter.BeginTiming()) {
var result = new CSharpAstResolver(compilation, unit, parsedFile);
result.ApplyNavigator(new ConstantModeResolveVisitorNavigator(ResolveVisitorNavigationMode.Resolve, null), token);
return(result);
}
} catch (OperationCanceledException) {
return(null);
} catch (Exception e) {
LoggingService.LogError("Error while creating the resolver.", e);
return(null);
}
}, token);
var wrapper = resolveTask.ContinueWith(t => {
if (t.IsCanceled)
{
return(null);
}
if (t.IsFaulted)
{
var ex = t.Exception.Flatten().InnerException;
if (!(ex is TaskCanceledException))
{
LoggingService.LogWarning("Exception while getting shared AST resolver.", ex);
}
return(null);
}
return(t.Result);
}, TaskContinuationOptions.ExecuteSynchronously);
document.AddAnnotation(new ResolverAnnotation {
Task = wrapper,
ParsedFile = parsedFile,
SharedTokenSource = tokenSource
});
return(wrapper);
}
void AnalyzeFile(JobSlice item, IEnumerable <BaseCodeIssueProvider> codeIssueProviders)
{
var file = item.File;
if (file.BuildAction != BuildAction.Compile)
{
return;
}
if (!(file.Project is DotNetProject))
{
return;
}
TextEditorData editor;
try {
editor = TextFileProvider.Instance.GetReadOnlyTextEditorData(file.FilePath);
} catch (FileNotFoundException) {
// Swallow exception and ignore this file
return;
}
var document = TypeSystemService.ParseFile(file.Project, editor);
if (document == null)
{
return;
}
var content = TypeSystemService.GetProjectContext(file.Project);
var compilation = content.AddOrUpdateFiles(document.ParsedFile).CreateCompilation();
CSharpAstResolver resolver;
using (var timer = ExtensionMethods.ResolveCounter.BeginTiming()) {
resolver = new CSharpAstResolver(compilation, document.GetAst <SyntaxTree> (), document.ParsedFile as ICSharpCode.NRefactory.CSharp.TypeSystem.CSharpUnresolvedFile);
try {
resolver.ApplyNavigator(new ExtensionMethods.ConstantModeResolveVisitorNavigator(ResolveVisitorNavigationMode.Resolve, null));
} catch (Exception e) {
LoggingService.LogError("Error while applying navigator", e);
}
}
var context = document.CreateRefactoringContextWithEditor(editor, resolver, CancellationToken.None);
foreach (var provider in codeIssueProviders)
{
if (item.CancellationToken.IsCancellationRequested)
{
break;
}
IList <IAnalysisJob> jobs;
lock (_lock)
jobs = item.GetJobs().ToList();
var jobsForProvider = jobs.Where(j => j.GetIssueProviders(file).Contains(provider)).ToList();
try {
var issues = provider.GetIssues(context, CancellationToken.None).ToList();
foreach (var job in jobsForProvider)
{
// Call AddResult even if issues.Count == 0, to enable a job implementation to keep
// track of progress information.
job.AddResult(file, provider, issues);
}
} catch (OperationCanceledException) {
// The operation was cancelled, no-op as the user-visible parts are
// handled elsewhere
} catch (Exception e) {
foreach (var job in jobsForProvider)
{
job.AddError(file, provider);
}
}
}
}
public IEnumerable <JsType> Compile(PreparedCompilation compilation)
{
_compilation = compilation.Compilation;
_types = new Dictionary <ITypeDefinition, JsClass>();
_constructorDeclarations = new HashSet <Tuple <ConstructorDeclaration, CSharpAstResolver> >();
_instanceInitStatements = new Dictionary <JsClass, List <JsStatement> >();
foreach (var f in compilation.SourceFiles)
{
try {
_resolver = new CSharpAstResolver(_compilation, f.SyntaxTree, f.ParsedFile);
_resolver.ApplyNavigator(new ResolveAllNavigator());
f.SyntaxTree.AcceptVisitor(this);
}
catch (Exception ex) {
_errorReporter.Region = _currentNode.GetRegion();
_errorReporter.InternalError(ex);
}
}
// Handle constructors. We must do this after we have visited all the compilation units because field initializer (which change the InstanceInitStatements and StaticInitStatements) might appear anywhere.
foreach (var n in _constructorDeclarations)
{
try {
_resolver = n.Item2;
HandleConstructorDeclaration(n.Item1);
}
catch (Exception ex) {
_errorReporter.Region = n.Item1.GetRegion();
_errorReporter.InternalError(ex);
}
}
// Add default constructors where needed.
foreach (var toAdd in _types.Where(t => t.Value != null).SelectMany(kvp => kvp.Key.GetConstructors().Where(c => c.IsSynthetic).Select(c => new { jsClass = kvp.Value, c })))
{
try {
MaybeAddDefaultConstructorToType(toAdd.jsClass, toAdd.c);
}
catch (Exception ex) {
_errorReporter.Region = toAdd.c.Region;
_errorReporter.InternalError(ex, "Error adding default constructor to type");
}
}
_types.Values.Where(t => t != null).ForEach(t => t.Freeze());
var enums = new List <JsType>();
foreach (var e in _compilation.MainAssembly.TopLevelTypeDefinitions.SelectMany(SelfAndNested).Where(t => t.Kind == TypeKind.Enum))
{
try {
enums.Add(ConvertEnum(e.GetDefinition()));
}
catch (Exception ex) {
_errorReporter.Region = e.GetDefinition().Region;
_errorReporter.InternalError(ex);
}
}
return(_types.Values.Concat(enums).Where(t => t != null));
}
