string Visit(LocalResolveResult result)
{
if (result.IsParameter)
return result.Variable.Name;
return result.Variable.Name;
}
Value VisitAssignment(LocalResolveResult lhs, ResolveResult rhs)
{
var value = Convert(rhs);
if (lhs.IsParameter)
context.GetArgumentValue(lhs.Variable.Name).SetValue(evalThread, value);
else
context.GetLocalVariableValue(lhs.Variable.Name).SetValue(evalThread, value);
return value;
}
Value Visit(LocalResolveResult result)
{
if (result.IsParameter)
return context.GetArgumentValue(result.Variable.Name);
return context.GetLocalVariableValue(result.Variable.Name);
}
bool HasDependencyCheck(FindReferences referenceFinder, LocalResolveResult localResolveResult)
{
bool result = false;
referenceFinder.FindLocalReferences(localResolveResult.Variable, context.UnresolvedFile,
(SyntaxTree)context.RootNode, context.Compilation,
(node, resolveResult) => {
result |= VariableHasBeenConverted(localResolveResult.Variable);
}, CancellationToken.None);
return result;
}
void CollectIssues(AstNode variableDecl, BlockStatement rootStatement, LocalResolveResult resolveResult)
{
if (rootStatement == null || resolveResult == null)
{
return;
}
var references = new HashSet <AstNode> ();
var refStatements = new HashSet <Statement> ();
var usedInLambda = false;
refFinder.FindLocalReferences(resolveResult.Variable, ctx.UnresolvedFile, unit, ctx.Compilation,
(astNode, rr) => {
if (usedInLambda || astNode == variableDecl)
{
return;
}
var parent = astNode.Parent;
while (!(parent == null || parent is Statement || parent is LambdaExpression))
{
parent = parent.Parent;
}
if (parent == null)
{
return;
}
var statement = parent as Statement;
if (statement != null)
{
references.Add(astNode);
refStatements.Add(statement);
}
while (parent != null && parent != rootStatement)
{
if (parent is LambdaExpression || parent is AnonymousMethodExpression)
{
usedInLambda = true;
break;
}
parent = parent.Parent;
}
}, ctx.CancellationToken);
// stop analyzing if the variable is used in any lambda expression or anonymous method
if (usedInLambda)
{
return;
}
var startNode = VariableReferenceGraphBuilder.Build(rootStatement, references, refStatements, ctx);
var variableInitializer = variableDecl as VariableInitializer;
if (variableInitializer != null && !variableInitializer.Initializer.IsNull)
{
startNode.References.Insert(0, variableInitializer);
}
ProcessNodes(startNode);
}
static string GetText(ResolveResult result, string expression, out bool debuggerCanShowValue)
{
debuggerCanShowValue = false;
if (result == null)
{
// when pressing control, show the expression even when it could not be resolved
return((Control.ModifierKeys == Keys.Control) ? "" : null);
}
if (result is MixedResolveResult)
{
return(GetText(((MixedResolveResult)result).PrimaryResult, expression, out debuggerCanShowValue));
}
else if (result is DelegateCallResolveResult)
{
return(GetText(((DelegateCallResolveResult)result).Target, expression, out debuggerCanShowValue));
}
IAmbience ambience = AmbienceService.GetCurrentAmbience();
ambience.ConversionFlags = ConversionFlags.StandardConversionFlags | ConversionFlags.UseFullyQualifiedMemberNames;
if (result is MemberResolveResult)
{
return(GetMemberText(ambience, ((MemberResolveResult)result).ResolvedMember, expression, out debuggerCanShowValue));
}
else if (result is LocalResolveResult)
{
LocalResolveResult rr = (LocalResolveResult)result;
ambience.ConversionFlags = ConversionFlags.UseFullyQualifiedTypeNames
| ConversionFlags.ShowReturnType | ConversionFlags.ShowDefinitionKeyWord;
StringBuilder b = new StringBuilder();
if (rr.IsParameter)
{
b.Append(StringParser.Parse("${res:MainWindow.Editor.Tooltip.Parameter} "));
}
else
{
b.Append(StringParser.Parse("${res:MainWindow.Editor.Tooltip.LocalVar} "));
}
b.Append(ambience.Convert(rr.Field));
if (currentDebugger != null)
{
string currentValue = currentDebugger.GetValueAsString(rr.VariableName);
if (currentValue != null)
{
debuggerCanShowValue = true;
b.Append(" = ");
if (currentValue.Length > 256)
{
currentValue = currentValue.Substring(0, 256) + "...";
}
b.Append(currentValue);
}
}
return(b.ToString());
}
else if (result is NamespaceResolveResult)
{
return(StringParser.Parse("${res:MainWindow.Editor.Tooltip.Namespace} ") + ((NamespaceResolveResult)result).Name);
}
else if (result is TypeResolveResult)
{
IClass c = ((TypeResolveResult)result).ResolvedClass;
if (c != null)
{
return(GetMemberText(ambience, c, expression, out debuggerCanShowValue));
}
else
{
return(ambience.Convert(result.ResolvedType));
}
}
else if (result is MethodGroupResolveResult)
{
MethodGroupResolveResult mrr = result as MethodGroupResolveResult;
IMethod m = mrr.GetMethodIfSingleOverload();
IMethod m2 = mrr.GetMethodWithEmptyParameterList();
if (m != null)
{
return(GetMemberText(ambience, m, expression, out debuggerCanShowValue));
}
else if (ambience is VBNetAmbience && m2 != null)
{
return(GetMemberText(ambience, m2, expression, out debuggerCanShowValue));
}
else
{
return(StringParser.Parse("${res:MainWindow.Editor.Tooltip.UnresolvedOverload} ") + ambience.Convert(mrr.ContainingType) + "." + mrr.Name);
}
}
else
{
if (Control.ModifierKeys == Keys.Control)
{
if (result.ResolvedType != null)
{
return("expression of type " + ambience.Convert(result.ResolvedType));
}
else
{
return("ResolveResult without ResolvedType");
}
}
else
{
return(null);
}
}
}
private JsBlockStatement GenerateUsingBlock(LocalResolveResult resource, Expression aquisitionExpression, DomRegion tempVariableRegion, JsBlockStatement body) {
SetRegion(aquisitionExpression.GetRegion());
var boolType = _compilation.FindType(KnownTypeCode.Boolean);
var systemIDisposable = _compilation.FindType(KnownTypeCode.IDisposable);
var disposeMethod = systemIDisposable.GetMethods().Single(m => m.Name == "Dispose");
var conversions = CSharpConversions.Get(_compilation);
var aquisitionResolveResult = _resolver.Resolve(aquisitionExpression);
var compiledAquisition = _expressionCompiler.Compile(aquisitionResolveResult, true);
var stmts = new List<JsStatement>();
stmts.AddRange(compiledAquisition.AdditionalStatements);
stmts.Add(JsStatement.Var(_variables[resource.Variable].Name, MaybeCloneValueType(compiledAquisition.Expression, aquisitionResolveResult, resource.Type)));
bool isDynamic = resource.Type.Kind == TypeKind.Dynamic;
if (isDynamic) {
var newResource = CreateTemporaryVariable(systemIDisposable, tempVariableRegion);
var castExpr = _expressionCompiler.Compile(new ConversionResolveResult(systemIDisposable, resource, conversions.ExplicitConversion(resource, systemIDisposable)), true);
stmts.AddRange(castExpr.AdditionalStatements);
stmts.Add(JsStatement.Var(_variables[newResource].Name, castExpr.Expression));
resource = new LocalResolveResult(newResource);
}
var compiledDisposeCall = _expressionCompiler.Compile(
new CSharpInvocationResolveResult(
new ConversionResolveResult(systemIDisposable, resource, conversions.ImplicitConversion(resource, systemIDisposable)),
disposeMethod,
new ResolveResult[0]
), false);
if (compiledDisposeCall.AdditionalStatements.Count > 0)
_errorReporter.InternalError("Type test cannot return additional statements.");
JsStatement releaseStmt;
if (isDynamic) {
releaseStmt = compiledDisposeCall.Expression;
}
else {
// if (d != null) ((IDisposable)d).Dispose()
var compiledTest = _expressionCompiler.Compile(new OperatorResolveResult(boolType, ExpressionType.NotEqual, resource, new ConstantResolveResult(resource.Type, null)), true);
if (compiledTest.AdditionalStatements.Count > 0)
_errorReporter.InternalError("Null test cannot return additional statements.");
releaseStmt = resource.Type.IsReferenceType == false && !resource.Type.IsKnownType(KnownTypeCode.NullableOfT) ? (JsStatement)compiledDisposeCall.Expression : JsStatement.If(compiledTest.Expression, compiledDisposeCall.Expression, null);
}
stmts.Add(JsStatement.Try(body, null, releaseStmt));
return JsStatement.Block(stmts);
}
private JsBlockStatement GenerateUsingBlock(LocalResolveResult resource, Expression aquisitionExpression, DomRegion tempVariableRegion, JsBlockStatement body)
{
var boolType = _compilation.FindType(KnownTypeCode.Boolean);
var systemIDisposable = _compilation.FindType(KnownTypeCode.IDisposable);
var disposeMethod = systemIDisposable.GetMethods().Single(m => m.Name == "Dispose");
var conversions = CSharpConversions.Get(_compilation);
var compiledAquisition = CompileExpression(aquisitionExpression, true);
var stmts = new List<JsStatement>();
stmts.AddRange(compiledAquisition.AdditionalStatements);
stmts.Add(new JsVariableDeclarationStatement(new JsVariableDeclaration(_variables[resource.Variable].Name, compiledAquisition.Expression)));
bool isDynamic = resource.Type.Kind == TypeKind.Dynamic;
if (isDynamic) {
var newResource = CreateTemporaryVariable(systemIDisposable, tempVariableRegion);
var castExpr = _expressionCompiler.Compile(_filename, aquisitionExpression.StartLocation, new ConversionResolveResult(systemIDisposable, resource, conversions.ExplicitConversion(resource, systemIDisposable)), true);
stmts.AddRange(castExpr.AdditionalStatements);
stmts.Add(new JsVariableDeclarationStatement(new JsVariableDeclaration(_variables[newResource].Name, castExpr.Expression)));
resource = new LocalResolveResult(newResource);
}
var compiledDisposeCall = _expressionCompiler.Compile(_filename, aquisitionExpression.StartLocation,
new CSharpInvocationResolveResult(
new ConversionResolveResult(systemIDisposable, resource, conversions.ImplicitConversion(resource, systemIDisposable)),
disposeMethod,
new ResolveResult[0]
), false);
if (compiledDisposeCall.AdditionalStatements.Count > 0)
_errorReporter.InternalError("Type test cannot return additional statements.", _filename, aquisitionExpression.StartLocation);
JsStatement releaseStmt;
if (isDynamic) {
releaseStmt = new JsExpressionStatement(compiledDisposeCall.Expression);
}
else {
// if (d != null) ((IDisposable)d).Dispose()
var compiledTest = _expressionCompiler.Compile(_filename, aquisitionExpression.StartLocation, new OperatorResolveResult(boolType, ExpressionType.NotEqual, resource, new ConstantResolveResult(resource.Type, null)), true);
if (compiledTest.AdditionalStatements.Count > 0)
_errorReporter.InternalError("Null test cannot return additional statements.", _filename, aquisitionExpression.StartLocation);
releaseStmt = new JsIfStatement(compiledTest.Expression, new JsExpressionStatement(compiledDisposeCall.Expression), null);
}
stmts.Add(new JsTryCatchFinallyStatement(body, null, releaseStmt));
return new JsBlockStatement(stmts);
}
public ReferenceResult(AstNode node, LocalResolveResult resolveResult)
{
Node = node;
ResolveResult = resolveResult;
}
public override object VisitLocalResolveResult(LocalResolveResult rr, object data)
{
_usedVariables.Add(rr.Variable);
return(base.VisitLocalResolveResult(rr, data));
}
public virtual TResult VisitLocalResolveResult(LocalResolveResult rr, TData data)
{
VisitChildResolveResults(rr, data);
return(default(TResult));
}
void CollectIssues (AstNode variableDecl, BlockStatement rootStatement, LocalResolveResult resolveResult)
{
if (rootStatement == null || resolveResult == null)
return;
var references = new HashSet<AstNode> ();
var refStatements = new HashSet<Statement> ();
var usedInLambda = false;
refFinder.FindLocalReferences (resolveResult.Variable, ctx.UnresolvedFile, unit, ctx.Compilation,
(astNode, rr) => {
if (usedInLambda || astNode == variableDecl)
return;
var parent = astNode.Parent;
while (!(parent == null || parent is Statement || parent is LambdaExpression))
parent = parent.Parent;
if (parent == null)
return;
var statement = parent as Statement;
if (statement != null) {
references.Add (astNode);
refStatements.Add (statement);
}
while (parent != null && parent != rootStatement) {
if (parent is LambdaExpression || parent is AnonymousMethodExpression) {
usedInLambda = true;
break;
}
parent = parent.Parent;
}
}, ctx.CancellationToken);
// stop analyzing if the variable is used in any lambda expression or anonymous method
if (usedInLambda)
return;
var startNode = VariableReferenceGraphBuilder.Build (rootStatement, references, refStatements, ctx);
var variableInitializer = variableDecl as VariableInitializer;
if (variableInitializer != null && !variableInitializer.Initializer.IsNull)
startNode.References.Insert (0, variableInitializer);
ProcessNodes (startNode);
}
public ReferenceResult(AstNode node, LocalResolveResult resolveResult)
{
Node = node;
ResolveResult = resolveResult;
}
public override object TrackedVisitAssignmentExpression(AssignmentExpression assignmentExpression, object data)
{
if (this.FoundResourceSet == null && // skip if already found to improve performance
assignmentExpression.Op == AssignmentOperatorType.Assign && this.PositionAvailable &&
(!this.isLocalVariable || this.resourceManagerMember.Region.IsInside(this.CurrentNodeStartLocation.Y, this.CurrentNodeStartLocation.X)) // skip if local variable is out of scope
)
{
IMember resolvedMember = null;
ResolveResult rr = this.Resolve(assignmentExpression.Left);
if (rr != null)
{
// Support both local variables and member variables
MemberResolveResult mrr = rr as MemberResolveResult;
if (mrr != null)
{
resolvedMember = mrr.ResolvedMember;
}
else
{
LocalResolveResult lrr = rr as LocalResolveResult;
if (lrr != null)
{
resolvedMember = lrr.Field;
}
}
}
if (resolvedMember != null)
{
#if DEBUG
LoggingService.Debug("ResourceToolkit: BclNRefactoryResourceResolver: Resolved member: " + resolvedMember.ToString());
#endif
// HACK: The GetType()s are necessary because the DOM IComparable implementations try to cast the parameter object to their own interface type which may fail.
if (resolvedMember.GetType().Equals(this.resourceManagerMember.GetType()) && resolvedMember.CompareTo(this.resourceManagerMember) == 0)
{
#if DEBUG
LoggingService.Debug("ResourceToolkit: BclNRefactoryResourceResolver found assignment to field: " + assignmentExpression.ToString());
#endif
data = true;
// Resolving the property association only makes sense if
// there is a possible relationship between the return types
// of the resolved member and the member we are looking for.
}
else if (this.compilationUnit != null && !this.isLocalVariable &&
IsTypeRelationshipPossible(resolvedMember, this.resourceManagerMember))
{
if (this.resourceManagerMember is IProperty && resolvedMember is IField)
{
// Find out if the resourceManagerMember is a property whose get block returns the value of the resolved member.
// We might already have found this association in the
// resourceManagerFieldAccessedByProperty field.
this.TryResolveResourceManagerProperty();
if (this.resourceManagerFieldAccessedByProperty != null && this.resourceManagerFieldAccessedByProperty.CompareTo(resolvedMember) == 0)
{
#if DEBUG
LoggingService.Debug("ResourceToolkit: BclNRefactoryResourceResolver found assignment to field: " + assignmentExpression.ToString());
#endif
data = true;
}
}
else if (this.resourceManagerMember is IField && resolvedMember is IProperty)
{
// Find out if the resolved member is a property whose set block assigns the value to the resourceManagerMember.
PropertyFieldAssociationVisitor visitor = new PropertyFieldAssociationVisitor((IField)this.resourceManagerMember, this.FileName, this.FileContent);
this.compilationUnit.AcceptVisitor(visitor, null);
if (visitor.AssociatedProperty != null && visitor.AssociatedProperty.CompareTo(resolvedMember) == 0)
{
#if DEBUG
LoggingService.Debug("ResourceToolkit: BclNRefactoryResourceResolver found assignment to property: " + assignmentExpression.ToString());
#endif
data = true;
}
}
}
}
}
return(base.TrackedVisitAssignmentExpression(assignmentExpression, data));
}
static string GetText(ResolveResult result)
{
if (result == null)
{
return(null);
}
if (result is MixedResolveResult)
{
return(GetText(((MixedResolveResult)result).PrimaryResult));
}
IAmbience ambience = MainForm.IsVisualBasic ? (IAmbience) new VBNetAmbience() : new CSharpAmbience();
ambience.ConversionFlags = ConversionFlags.StandardConversionFlags | ConversionFlags.ShowAccessibility;
if (result is MemberResolveResult)
{
return(GetMemberText(ambience, ((MemberResolveResult)result).ResolvedMember));
}
else if (result is LocalResolveResult)
{
LocalResolveResult rr = (LocalResolveResult)result;
ambience.ConversionFlags = ConversionFlags.UseFullyQualifiedTypeNames
| ConversionFlags.ShowReturnType;
StringBuilder b = new StringBuilder();
if (rr.IsParameter)
{
b.Append("parameter ");
}
else
{
b.Append("local variable ");
}
b.Append(ambience.Convert(rr.Field));
return(b.ToString());
}
else if (result is NamespaceResolveResult)
{
return("namespace " + ((NamespaceResolveResult)result).Name);
}
else if (result is TypeResolveResult)
{
IClass c = ((TypeResolveResult)result).ResolvedClass;
if (c != null)
{
return(GetMemberText(ambience, c));
}
else
{
return(ambience.Convert(result.ResolvedType));
}
}
else if (result is MethodGroupResolveResult)
{
MethodGroupResolveResult mrr = result as MethodGroupResolveResult;
IMethod m = mrr.GetMethodIfSingleOverload();
if (m != null)
{
return(GetMemberText(ambience, m));
}
else
{
return("Overload of " + ambience.Convert(mrr.ContainingType) + "." + mrr.Name);
}
}
else
{
return(null);
}
}
static string GetText(ResolveResult result, string expression, out bool debuggerCanShowValue)
{
debuggerCanShowValue = false;
if (result == null)
{
// when pressing control, show the expression even when it could not be resolved
return((Control.ModifierKeys == Keys.Control) ? "" : null);
}
if (result is MixedResolveResult)
{
return(GetText(((MixedResolveResult)result).PrimaryResult, expression, out debuggerCanShowValue));
}
IAmbience ambience = AmbienceService.CurrentAmbience;
ambience.ConversionFlags = ConversionFlags.StandardConversionFlags | ConversionFlags.ShowAccessibility;
if (result is MemberResolveResult)
{
return(GetMemberText(ambience, ((MemberResolveResult)result).ResolvedMember, expression, out debuggerCanShowValue));
}
else if (result is LocalResolveResult)
{
LocalResolveResult rr = (LocalResolveResult)result;
ambience.ConversionFlags = ConversionFlags.UseFullyQualifiedNames
| ConversionFlags.ShowReturnType
| ConversionFlags.QualifiedNamesOnlyForReturnTypes;
StringBuilder b = new StringBuilder();
if (rr.IsParameter)
{
b.Append("parameter ");
}
else
{
b.Append("local variable ");
}
b.Append(ambience.Convert(rr.Field));
if (currentDebugger != null)
{
string currentValue = currentDebugger.GetValueAsString(rr.Field.Name);
if (currentValue != null)
{
debuggerCanShowValue = true;
b.Append(" = ");
b.Append(currentValue);
}
}
return(b.ToString());
}
else if (result is NamespaceResolveResult)
{
return("namespace " + ((NamespaceResolveResult)result).Name);
}
else if (result is TypeResolveResult)
{
IClass c = ((TypeResolveResult)result).ResolvedClass;
if (c != null)
{
return(GetMemberText(ambience, c, expression, out debuggerCanShowValue));
}
else
{
return(ambience.Convert(result.ResolvedType));
}
}
else if (result is MethodResolveResult)
{
MethodResolveResult mrr = result as MethodResolveResult;
IMethod m = mrr.GetMethodIfSingleOverload();
if (m != null)
{
return(GetMemberText(ambience, m, expression, out debuggerCanShowValue));
}
else
{
return("Overload of " + ambience.Convert(mrr.ContainingType) + "." + mrr.Name);
}
}
else
{
if (Control.ModifierKeys == Keys.Control)
{
if (result.ResolvedType != null)
{
return("expression of type " + ambience.Convert(result.ResolvedType));
}
else
{
return("ResolveResult without ResolvedType");
}
}
else
{
return(null);
}
}
}
void CollectIssues(AstNode variableDecl, BlockStatement rootStatement, LocalResolveResult resolveResult)
{
if (rootStatement == null || resolveResult == null)
{
return;
}
var references = new HashSet <AstNode>();
var refStatements = new HashSet <Statement>();
var usedInLambda = false;
var results = ctx.FindReferences(rootStatement, resolveResult.Variable);
foreach (var result in results)
{
var node = result.Node;
if (node == variableDecl)
{
continue;
}
var parent = node.Parent;
while (!(parent == null || parent is Statement || parent is LambdaExpression))
{
parent = parent.Parent;
}
if (parent == null)
{
continue;
}
var statement = parent as Statement;
if (statement != null)
{
references.Add(node);
refStatements.Add(statement);
}
while (parent != null && parent != rootStatement)
{
if (parent is LambdaExpression || parent is AnonymousMethodExpression)
{
usedInLambda = true;
break;
}
parent = parent.Parent;
}
if (usedInLambda)
{
break;
}
}
// stop analyzing if the variable is used in any lambda expression or anonymous method
if (usedInLambda)
{
return;
}
var startNode = new VariableReferenceGraphBuilder(ctx).Build(rootStatement, references, refStatements, ctx);
var variableInitializer = variableDecl as VariableInitializer;
if (variableInitializer != null && !variableInitializer.Initializer.IsNull)
{
startNode.References.Insert(0, variableInitializer);
}
ProcessNodes(startNode);
}
public void ClosureTypelessArgument()
{
LocalResolveResult rr = Resolve <LocalResolveResult>("myObject", "/*inRecursiveClosure*/");
Assert.AreEqual("System.Object", rr.ResolvedType.FullyQualifiedName);
}
void CollectIssues(AstNode variableDecl, AstNode rootNode, LocalResolveResult resolveResult)
{
if (resolveResult == null)
return;
var type = resolveResult.Type;
var typeDef = type.GetDefinition ();
if (typeDef == null ||
(typeDef.KnownTypeCode != KnownTypeCode.IEnumerable &&
typeDef.KnownTypeCode != KnownTypeCode.IEnumerableOfT))
return;
FindReferences (variableDecl, rootNode, resolveResult.Variable);
var statements = AnalysisStatementCollector.Collect (variableDecl);
var builder = new VariableReferenceGraphBuilder (ctx);
foreach (var statement in statements) {
var vrNode = builder.Build (statement, references, refStatements, ctx);
FindMultipleEnumeration (vrNode);
}
foreach (var lambda in lambdaExpressions) {
var vrNode = builder.Build (references, ctx.Resolver, (Expression)lambda.Body);
FindMultipleEnumeration (vrNode);
}
}
public void Boo629VariableScope()
{
LocalResolveResult rr = Resolve <LocalResolveResult>(regressionProg, "boo629", "/*1*/");
Assert.AreEqual("System.String", rr.ResolvedType.FullyQualifiedName);
}
private JsBlockStatement CompileCatchClause(LocalResolveResult catchVariable, CatchClause catchClause, bool isCatchAll, bool isOnly) {
SetRegion(catchClause.GetRegion());
JsStatement variableDeclaration = null;
if (!catchClause.VariableNameToken.IsNull) {
JsExpression compiledAssignment;
if (isCatchAll) // If this is the only handler we need to construct the exception
compiledAssignment = isOnly ? _runtimeLibrary.MakeException(JsExpression.Identifier(_variables[catchVariable.Variable].Name), this) : JsExpression.Identifier(_variables[catchVariable.Variable].Name);
else
compiledAssignment = _runtimeLibrary.Downcast(JsExpression.Identifier(_variables[catchVariable.Variable].Name), _compilation.FindType(KnownTypeCode.Exception), _resolver.Resolve(catchClause.Type).Type, this);
variableDeclaration = JsStatement.Var(_variables[((LocalResolveResult)_resolver.Resolve(catchClause.VariableNameToken)).Variable].Name, compiledAssignment);
}
var result = CreateInnerCompiler().Compile(catchClause.Body);
if (variableDeclaration != null)
result = JsStatement.Block(new[] { variableDeclaration }.Concat(result.Statements));
return result;
}
public virtual object VisitLocalResolveResult(LocalResolveResult rr, object data)
{
VisitChildResolveResults(rr, data);
return(null);
}
public override object VisitLocalResolveResult(LocalResolveResult rr, object data) {
_usedVariables.Add(rr.Variable);
return base.VisitLocalResolveResult(rr, data);
}
public object VisitLocalResolveResult(LocalResolveResult res)
{
throw new NotImplementedException();
}
