protected virtual string GetVariableMangledName (LocalVariable local_info)
{
//
// No need to mangle anonymous method hoisted variables cause they
// are hoisted in their own scopes
//
return local_info.Name;
}
void case_960()
#line 6406 "cs-parser.jay"
{
start_block (GetLocation (yyVals[-5+yyTop]));
current_block.IsCompilerGenerated = true;
var lt = (LocatedToken) yyVals[-3+yyTop];
var li = new LocalVariable (current_block, lt.Value, LocalVariable.Flags.ForeachVariable | LocalVariable.Flags.Used, lt.Location);
current_block.AddLocalName (li);
yyVal = li;
}
public LocalVariableResolveResult (LocalVariable variable, bool isLoopVariable)
{
this.variable = variable;
this.isLoopVariable = isLoopVariable;
}
public VariableInfo (LocalVariable local_info, int offset)
: this (local_info.Name, local_info.Type, offset)
{
this.IsParameter = false;
}
void case_888()
#line 5956 "cs-parser.jay"
{
var lt = (LocatedToken) yyVals[0+yyTop];
var li = new LocalVariable (current_variable.Variable, lt.Value, lt.Location);
var d = new BlockVariableDeclarator (li, null);
current_variable.AddDeclarator (d);
current_block.AddLocalName (li);
lbag.AddLocation (d, GetLocation (yyVals[-1+yyTop]));
}
public bool RenameVariable (IProgressMonitor monitor, LocalVariable var, string newName)
{
try {
MemberReferenceCollection refs = new MemberReferenceCollection ();
Refactor (monitor, var, new RefactorDelegate (new RefactorFindVariableReferences (var, refs).Refactor));
refs.RenameAll (newName);
RefactorerContext gctx = GetGeneratorContext (var);
IRefactorer r = GetGeneratorForVariable (var);
bool rv = r.RenameVariable (gctx, var, newName);
gctx.Save ();
return rv;
} catch (Exception e) {
LoggingService.LogError (GettextCatalog.GetString ("Error while renaming {0} to {1}: {2}", var, newName, e.ToString ()));
return false;
}
}
ProjectDom GetParserContext (LocalVariable var)
{
Project p = GetProjectForFile (var.FileName);
if (p != null)
return ProjectDomService.GetProjectDom (p);
return ProjectDom.Empty;
}
public VariableValueReference(EvaluationContext ctx, string name, LocalVariable variable) : base(ctx)
{
this.variable = variable;
this.name = name;
}
public void CanGenerateHardCodedArtifactCatalogClass()
{
//-- arrange
var firstArtifactType = new TypeMember(MemberVisibility.Public, TypeMemberKind.Class, "FirstArtifact");
var secondArtifactType = new TypeMember(MemberVisibility.Public, TypeMemberKind.Class, "SecondArtifact");
var catalogType = new TypeMember(MemberVisibility.Public, TypeMemberKind.Class, "ThisAssemblyArtifactCatalog");
catalogType.BaseType = typeof(RuntimeTypeFactoryArtifactCatalog);
var getArtifactsMethod = new MethodMember(
MemberVisibility.Public,
MemberModifier.Override,
nameof(RuntimeTypeFactoryArtifactCatalog.GetArtifacts),
new MethodSignature {
ReturnValue = new MethodParameter {
Type = typeof(RuntimeTypeFactoryArtifact[])
}
});
var artifactsVariable = new LocalVariable {
Name = "artifacts"
};
getArtifactsMethod.Body = new BlockStatement(
new VariableDeclarationStatement {
Variable = artifactsVariable,
InitialValue = new NewArrayExpression {
ElementType = typeof(RuntimeTypeFactoryArtifact),
Length = new ConstantExpression {
Value = 2
}
},
},
new ExpressionStatement {
Expression = new AssignmentExpression {
Left = new IndexerExpression {
Target = new LocalVariableExpression {
Variable = artifactsVariable
},
Index = new ConstantExpression {
Value = 0
}
},
Right = new NewObjectExpression {
Type = firstArtifactType
}
}
},
new ExpressionStatement {
Expression = new AssignmentExpression {
Left = new IndexerExpression {
Target = new LocalVariableExpression {
Variable = artifactsVariable
},
Index = new ConstantExpression {
Value = 1
}
},
Right = new NewObjectExpression {
Type = secondArtifactType
}
}
},
new ReturnStatement {
Expression = new LocalVariableExpression {
Variable = artifactsVariable
}
}
);
catalogType.Members.Add(getArtifactsMethod);
//-- act
var syntaxEmitter = new ClassSyntaxEmitter(catalogType);
SyntaxNode actualSyntax;
using (TypeMemberTagCache.CreateOnCurrentThread())
{
actualSyntax = syntaxEmitter.EmitSyntax();
}
//-- assert
var expectedCode = @"
public class ThisAssemblyArtifactCatalog : NWheels.Compilation.Mechanism.Factories.RuntimeTypeFactoryArtifactCatalog
{
public override NWheels.Compilation.Mechanism.Factories.RuntimeTypeFactoryArtifact[] GetArtifacts()
{
var artifacts = new NWheels.Compilation.Mechanism.Factories.RuntimeTypeFactoryArtifact[2];
artifacts[0] = new FirstArtifact();
artifacts[1] = new SecondArtifact();
return artifacts;
}
}
";
actualSyntax.Should().BeEquivalentToCode(expectedCode);
}
public VariableDeclaration(LocalVariable li, Location loc)
: base(li)
{
reachable = true;
this.loc = loc;
}
public VariableDeclaration(FullNamedExpression type, LocalVariable li)
: base(type, li)
{
}
void RunTest(string test, LocalVariable localVariable)
{
StringBuilder testText = new StringBuilder();
List <DomLocation> expectedReferences = new List <DomLocation> ();
DomLocation memberLocation = DomLocation.Empty;
int line = 1, col = 1;
foreach (char ch in test)
{
switch (ch)
{
case '$':
memberLocation = new DomLocation(line, col);
break;
case '@':
expectedReferences.Add(new DomLocation(line, col));
break;
default:
col++;
if (ch == '\n')
{
col = 1;
line++;
}
testText.Append(ch);
break;
}
}
DotNetProject project = new DotNetAssemblyProject("C#");
project.FileName = "/tmp/a.csproj";
SimpleProjectDom dom = new SimpleProjectDom();
dom.Project = project;
ProjectDomService.RegisterDom(dom, "Project:" + project.FileName);
ParsedDocument parsedDocument = parser.Parse(null, "a.cs", testText.ToString());
dom.Add(parsedDocument.CompilationUnit);
TestViewContent testViewContent = new TestViewContent();
testViewContent.Name = "a.cs";
testViewContent.Text = testText.ToString();
// RefactorerContext ctx = new RefactorerContext (dom, new DumbTextFileProvider(testViewContent), null);
NRefactoryResolver resolver = new NRefactoryResolver(dom,
parsedDocument.CompilationUnit,
testViewContent.Data,
"a.cs");
SearchMemberVisitor smv = new SearchMemberVisitor(memberLocation.Line);
if (localVariable != null)
{
((LocalVariable)localVariable).DeclaringMember = parsedDocument.CompilationUnit.GetMemberAt(expectedReferences[0]);
smv.FoundMember = localVariable;
}
else
{
smv.Visit(parsedDocument.CompilationUnit, null);
if (smv.FoundMember == null)
{
ResolveResult resolveResult = resolver.ResolveIdentifier("a", memberLocation);
if (resolveResult is LocalVariableResolveResult)
{
smv.FoundMember = ((LocalVariableResolveResult)resolveResult).LocalVariable;
}
}
}
Assert.IsNotNull(smv.FoundMember, "Member to search not found.");
if (smv.FoundMember is IType)
{
smv.FoundMember = dom.GetType(((IType)smv.FoundMember).FullName,
((IType)smv.FoundMember).TypeParameters.Count,
true);
}
FindMemberAstVisitor astVisitor = new FindMemberAstVisitor(testViewContent.GetTextEditorData().Document, resolver, smv.FoundMember);
astVisitor.RunVisitor();
int i = 0, j = 0;
StringBuilder errorText = new StringBuilder();
Document doc = new Document();
doc.Text = testViewContent.Text;
while (i < expectedReferences.Count && j < astVisitor.FoundReferences.Count)
{
if (expectedReferences[i].Line != astVisitor.FoundReferences[j].Line || expectedReferences[i].Column != astVisitor.FoundReferences[j].Column)
{
if (expectedReferences[i].Line < astVisitor.FoundReferences[j].Line)
{
errorText.Append("Reference at line " + expectedReferences[i].Line + " not found.");
errorText.AppendLine();
errorText.Append(doc.GetTextAt(doc.GetLine(expectedReferences[i].Line)).Replace('\t', ' '));
errorText.AppendLine();
errorText.Append(new string (' ', expectedReferences[i].Column)); errorText.Append('^');
errorText.AppendLine();
i++;
continue;
}
if (expectedReferences[i].Line > astVisitor.FoundReferences[j].Line)
{
errorText.Append("Found unexpected Reference at line " + astVisitor.FoundReferences[j].Line);
errorText.AppendLine();
errorText.Append(doc.GetTextAt(doc.GetLine(astVisitor.FoundReferences[j].Line)).Replace('\t', ' '));
errorText.AppendLine();
errorText.Append(new string (' ', astVisitor.FoundReferences[j].Column)); errorText.Append('^');
errorText.AppendLine();
j++;
continue;
}
errorText.Append("Column mismatch at line " + astVisitor.FoundReferences[j].Line + " was: " + astVisitor.FoundReferences[j].Column + " should be:" + expectedReferences[i].Column);
errorText.AppendLine();
errorText.Append(doc.GetTextAt(doc.GetLine(astVisitor.FoundReferences[j].Line)).Replace('\t', ' '));
errorText.Append(new string (' ', expectedReferences[i].Column)); errorText.Append('^');
errorText.AppendLine();
errorText.Append(new string (' ', astVisitor.FoundReferences[j].Column)); errorText.Append('^');
errorText.AppendLine();
}
i++; j++;
}
while (i < expectedReferences.Count)
{
errorText.Append("Reference at line " + expectedReferences[i].Line + " not found.");
errorText.AppendLine();
errorText.Append(doc.GetTextAt(doc.GetLine(expectedReferences[i].Line)).Replace('\t', ' '));
errorText.AppendLine();
errorText.Append(new string (' ', expectedReferences[j].Column)); errorText.Append('^');
errorText.AppendLine();
i++;
}
while (j < astVisitor.FoundReferences.Count)
{
errorText.Append("Found unexpected Reference at line " + astVisitor.FoundReferences[j].Line);
errorText.AppendLine();
errorText.Append(doc.GetTextAt(doc.GetLine(astVisitor.FoundReferences[j].Line)).Replace('\t', ' '));
errorText.AppendLine();
errorText.Append(new string (' ', astVisitor.FoundReferences[i].Column)); errorText.Append('^');
errorText.AppendLine();
j++;
}
if (errorText.Length > 0)
{
Assert.Fail("Member to find:" + smv.FoundMember + Environment.NewLine + errorText.ToString() + Environment.NewLine + "found : " + astVisitor.FoundReferences.Count + " expected:" + expectedReferences.Count);
}
}
public Node(LocalVariable var)
{
this.Kind = NodeKind.LeftVariable;
this.Var = var;
}
public HoistedLocalVariable (AnonymousMethodStorey storey, LocalVariable local, string name)
: base (storey, name, local.Type)
{
}
public MemberReferenceCollection FindVariableReferences(IProgressMonitor monitor, LocalVariable var)
{
MemberReferenceCollection refs = new MemberReferenceCollection();
Refactor(monitor, var, new RefactorDelegate(new RefactorFindVariableReferences(var, refs).Refactor));
return(refs);
}
public override IEnumerable <MemberReference> FindVariableReferences(RefactorerContext ctx, string fileName, LocalVariable var)
{
var editor = ((Mono.TextEditor.ITextEditorDataProvider)ctx.GetFile(fileName)).GetTextEditorData();
NRefactoryResolver resolver = new NRefactoryResolver(ctx.ParserContext, var.CompilationUnit, ICSharpCode.OldNRefactory.SupportedLanguage.CSharp, editor, fileName);
resolver.CallingMember = var.DeclaringMember;
FindMemberAstVisitor visitor = new FindMemberAstVisitor(editor.Document, var);
visitor.RunVisitor(resolver);
SetContext(visitor.FoundReferences, ctx);
return(visitor.FoundReferences);
}
/// <summary> Gets whether a captured variable with the <paramref name="name"/> exists. </summary>
public bool HasCapturedVariable(string name, out LocalVariable variable)
{
variable = GetLocalVariables(this.IP).FirstOrDefault(v => v.IsCaptured && v.Name == name);
return variable != null;
}
public static void InterceptConstructors(Builder builder)
{
if (!constructorInterceptionAttributes.Any())
{
return;
}
var constructors = builder
.FindMethodsByAttributes(constructorInterceptionAttributes)
.Where(x => !x.Method.OriginType.IsInterface)
.GroupBy(x => new MethodKey(x.Method, null))
.Select(x => new MethodBuilderInfo <MethodBuilderInfoItem <BuilderTypeIConstructorInterceptor> >(x.Key, x.Select(y => new MethodBuilderInfoItem <BuilderTypeIConstructorInterceptor>(y, BuilderTypes.IConstructorInterceptor))))
.ToArray();
foreach (var constructor in constructors)
{
if (constructor.Items == null || constructor.Items.Length == 0)
{
continue;
}
var targetedConstrutor = constructor.Key.Method;
if (!targetedConstrutor.IsCtor && !targetedConstrutor.IsCCtor)
{
continue;
}
builder.Log(LogTypes.Info, $"Implementing constructors interceptors: {constructor.Key.Method.DeclaringType.Name.PadRight(40, ' ')} {constructor.Key.Method.Name}({string.Join(", ", constructor.Key.Method.Parameters.Select(x => x.Name))})");
if (constructor.RequiresSyncRootField)
{
builder.Log(LogTypes.Warning, targetedConstrutor, $"An interceptor applied to the constructor has implemented ISyncRoot. This is not supported. The interceptor may not work correctly.");
}
CodeBlock parametersArray = null;
var localVariables = new LocalVariable[constructor.Items.Length];
Coder InterceptorInit(Coder contextCoder, bool isBeforeInit)
{
parametersArray = contextCoder.GetParametersArray();
for (int i = 0; i < constructor.Items.Length; i++)
{
var item = constructor.Items[i];
localVariables[i] = contextCoder.AssociatedMethod.GetOrCreateVariable(item.Interface.BuilderType);
contextCoder.SetValue(localVariables[i], x => x.NewObj(item.Attribute));
contextCoder.Load(localVariables[i]).Call(item.Interface.GetMethod_OnBeforeInitialization(), targetedConstrutor.OriginType, targetedConstrutor, parametersArray);
item.Attribute.Remove();
}
return(contextCoder);
}
if (targetedConstrutor.IsCtor)
{
targetedConstrutor.NewCoder()
.Context(x => InterceptorInit(x, true))
.Insert(InsertionPosition.CtorBeforeInit);
}
targetedConstrutor.NewCoder()
.Context(x =>
{
if (targetedConstrutor.IsCCtor)
{
InterceptorInit(x, false);
}
for (int i = 0; i < constructor.Items.Length; i++)
{
var item = constructor.Items[i];
ModuleWeaver.ImplementAssignMethodAttribute(builder, item.AssignMethodAttributeInfos, localVariables[i], item.Attribute.Attribute.Type, x);
item.Attribute.Remove();
}
return(x);
})
.Try(x =>
{
for (int i = 0; i < constructor.Items.Length; i++)
{
var item = constructor.Items[i];
x.Load(localVariables[i]).Call(item.Interface.GetMethod_OnEnter(), targetedConstrutor.OriginType, CodeBlocks.This, targetedConstrutor, parametersArray);
}
return(x);
})
.Catch(BuilderTypes.Exception.BuilderType, (ex, e) =>
{
return(ex.If(x => x.Or(constructor.Items, (coder, y, i) => coder.Load(localVariables[i]).Call(y.Interface.GetMethod_OnException(), e())).Is(true),
then => ex.NewCoder().Rethrow())
.DefaultValue()
.Return());
})
.Finally(x =>
{
for (int i = 0; i < constructor.Items.Length; i++)
{
x.Load(localVariables[i]).Call(constructor.Items[i].Interface.GetMethod_OnException());
}
return(x);
})
.EndTry()
.Return()
.Replace();
}
}
void Refactor (IProgressMonitor monitor, LocalVariable var, RefactorDelegate refactorDelegate)
{
RefactorerContext gctx = GetGeneratorContext (var);
string file = var.FileName;
IRefactorer gen = LanguageBindingService.GetRefactorerForFile (file);
if (gen == null)
return;
refactorDelegate (monitor, gctx, gen, file);
gctx.Save ();
}
protected void BeginInline(Implementation impl) {
Contract.Requires(impl != null);
Contract.Requires(impl.Proc != null);
Contract.Requires(newModifies != null);
Contract.Requires(newLocalVars != null);
Dictionary<Variable, Expr> substMap = new Dictionary<Variable, Expr>();
Procedure proc = impl.Proc;
foreach (Variable/*!*/ locVar in cce.NonNull(impl.OriginalLocVars)) {
Contract.Assert(locVar != null);
LocalVariable localVar = new LocalVariable(Token.NoToken, new TypedIdent(Token.NoToken, GetProcVarName(proc.Name, locVar.Name), locVar.TypedIdent.Type, locVar.TypedIdent.WhereExpr));
localVar.Attributes = locVar.Attributes; // copy attributes
newLocalVars.Add(localVar);
IdentifierExpr ie = new IdentifierExpr(Token.NoToken, localVar);
substMap.Add(locVar, ie);
}
for (int i = 0; i < impl.InParams.Count; i++) {
Variable inVar = cce.NonNull(impl.InParams[i]);
LocalVariable localVar = new LocalVariable(Token.NoToken, new TypedIdent(Token.NoToken, GetProcVarName(proc.Name, inVar.Name), inVar.TypedIdent.Type, inVar.TypedIdent.WhereExpr));
newLocalVars.Add(localVar);
if (impl.Proc != null) localVar.Attributes = impl.Proc.InParams[i].Attributes; // copy attributes
IdentifierExpr ie = new IdentifierExpr(Token.NoToken, localVar);
substMap.Add(inVar, ie);
// also add a substitution from the corresponding formal occurring in the PROCEDURE declaration
Variable procInVar = cce.NonNull(proc.InParams[i]);
if (procInVar != inVar) {
substMap.Add(procInVar, ie);
}
}
for (int i = 0; i < impl.OutParams.Count; i++) {
Variable outVar = cce.NonNull(impl.OutParams[i]);
LocalVariable localVar = new LocalVariable(Token.NoToken, new TypedIdent(Token.NoToken, GetProcVarName(proc.Name, outVar.Name), outVar.TypedIdent.Type, outVar.TypedIdent.WhereExpr));
if (impl.Proc != null) localVar.Attributes = impl.Proc.OutParams[i].Attributes; // copy attributes
newLocalVars.Add(localVar);
IdentifierExpr ie = new IdentifierExpr(Token.NoToken, localVar);
substMap.Add(outVar, ie);
// also add a substitution from the corresponding formal occurring in the PROCEDURE declaration
Variable procOutVar = cce.NonNull(proc.OutParams[i]);
if (procOutVar != outVar) {
substMap.Add(procOutVar, ie);
}
}
Dictionary<Variable, Expr> substMapOld = new Dictionary<Variable, Expr>();
foreach (IdentifierExpr/*!*/ mie in proc.Modifies) {
Contract.Assert(mie != null);
Variable/*!*/ mVar = cce.NonNull(mie.Decl);
LocalVariable localVar = new LocalVariable(Token.NoToken, new TypedIdent(Token.NoToken, GetProcVarName(proc.Name, mVar.Name), mVar.TypedIdent.Type));
newLocalVars.Add(localVar);
IdentifierExpr ie = new IdentifierExpr(Token.NoToken, localVar);
substMapOld.Add(mVar, ie);
// FIXME why are we doing this? the modifies list should already include them.
// add the modified variable to the modifies list of the procedure
if (!newModifies.Contains(mie)) {
newModifies.Add(mie);
}
}
codeCopier.Subst = Substituter.SubstitutionFromHashtable(substMap);
codeCopier.OldSubst = Substituter.SubstitutionFromHashtable(substMapOld);
}
public RefactorFindVariableReferences (LocalVariable var, MemberReferenceCollection references)
{
this.references = references;
this.var = var;
}
public bool CheckVariableDeclaration (ICS.VariableDeclarationStatement node, InspectionData data)
{
if ((MatchKind != 0 && (MatchKind & DeclarationKinds.LocalVariable) == 0) || !CheckModifiers (node.Modifiers, ICS.Modifiers.Private))
return false;
var member = data.Document.CompilationUnit.GetMemberAt (node.StartLocation.Line, node.StartLocation.Column);
foreach (var var in node.Variables) {
string name = var.Name;
if (IsValid (name))
continue;
var v = new LocalVariable (member, name, DomReturnType.Void,
new DomRegion (node.StartLocation.Line, node.StartLocation.Column,
node.EndLocation.Line, node.EndLocation.Column));
data.Add (GetFixableResult (var.NameToken.StartLocation, v, name));
}
return true;
}
void case_655()
#line 4671 "cs-parser.jay"
{
if (yyVals[0+yyTop] != null) {
var lt = (LocatedToken) yyVals[0+yyTop];
var variable = new LocalVariable (current_block, lt.Value, lt.Location);
current_block.AddLocalName (variable);
}
}
/// <summary>
/// called from the holding class
/// </summary>
/// <param name="reader"></param>
/// <param name="node"></param>
public void OnReadFromXmlNode(IXmlCodeReader reader0, XmlNode node)
{
XmlObjectReader reader = (XmlObjectReader)reader0;
//retrieve _holder, _event
UInt32 memberId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_EventId); //declaring event id
MemberId = memberId;
//
UInt32 varId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_varId);
if (varId != 0)
{
ClassPointer root0 = reader.ObjectList.GetTypedData <ClassPointer>();
LocalVariable lv = root0.GetLocalVariable(varId);
_holder = lv;
ClassId = lv.ClassType.DefinitionClassId;
ClassPointer r = reader.ObjectList.Project.GetTypedData <ClassPointer>(ClassId);
_event = r.GetCustomEventById(memberId);
}
else
{
XmlNode nd = node.SelectSingleNode(XmlTags.XML_ClassInstance);
if (nd != null)
{
ClassInstancePointer cp = new ClassInstancePointer();
cp.OnPostSerialize(reader.ObjectList, nd, false, reader);
_event = cp.Definition.GetCustomEventById(memberId);
_holder = cp;
ClassId = cp.DefinitionClassId;
}
else
{
UInt32 cid = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ownerClassID);
if (cid != 0)
{
ClassPointer root0 = ClassPointer.CreateClassPointer(cid, reader.ObjectList.Project);
_holder = root0;
ClassId = root0.ClassId;
_event = root0.GetCustomEventById(memberId);
}
else
{
if (XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ClassID) == 0)
{
ClassPointer root0 = reader.ObjectList.GetTypedData <ClassPointer>();
_holder = root0;
ClassId = root0.ClassId;
_event = root0.GetCustomEventById(memberId);
}
}
}
}
if (_event == null)
{
//===backward compatibility==================================================
UInt32 instId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_instanceId);
if (instId != 0)
{
XmlNode nd = node.SelectSingleNode(XmlTags.XML_ClassInstance);
if (nd != null)
{
ClassInstancePointer cp = new ClassInstancePointer();
cp.OnPostSerialize(reader.ObjectList, nd, false, reader);
ClassInstancePointer vi = (ClassInstancePointer)cp.Definition.ObjectList.GetClassRefById(instId);
MemberComponentIdCustomInstance mcci = new MemberComponentIdCustomInstance(cp, vi, instId);
_holder = mcci;
_event = vi.Definition.GetCustomEventById(memberId);
ClassId = vi.ClassId;
}
else
{
ClassPointer root0 = reader.ObjectList.GetTypedData <ClassPointer>();
ClassInstancePointer cp = (ClassInstancePointer)reader.ObjectList.GetClassRefById(instId);
MemberComponentIdCustom mcc = new MemberComponentIdCustom(root0, cp, instId);
_holder = mcc;
_event = cp.Definition.GetCustomEventById(memberId);
ClassId = cp.ClassId;
}
}
else
{
if (XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ClassID) == 0)
{
ClassPointer root0 = reader.ObjectList.GetTypedData <ClassPointer>();
_holder = root0;
ClassId = root0.ClassId;
_holder = root0;
_event = root0.GetCustomEventById(memberId);
}
else
{
//backward compatibility
UInt32 classId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ClassID); //declaring class id
UInt32 holderMemberId = XmlUtil.GetAttributeUInt(node, XmlTags.XMLATT_ComponentID); //holding class member id
ClassId = classId;
MemberId = memberId;
UInt32 holderClassId = XmlUtil.GetAttributeUInt(node.OwnerDocument.DocumentElement, XmlTags.XMLATT_ClassID);
ClassPointer root = reader.ObjectList.Project.GetTypedData <ClassPointer>(holderClassId);
if (holderClassId == classId) //holder is in the same class
{
_event = root.GetCustomEventById(memberId);
if (holderMemberId == 0 || holderMemberId == reader.ObjectList.MemberId) //not an instance
{
_holder = ClassPointer.CreateClassPointer(reader.ObjectList);
}
else
{
_holder = (IClass)reader.ObjectList.GetClassRefById(holderMemberId);
}
}
else //holder and declarer are different classes
{
ClassPointer baseClass = root.GetBaseClass(classId);
if (baseClass != null)
{
EventClass eb = baseClass.GetCustomEventById(memberId);
if (eb == null)
{
throw new DesignerException("Error reading custom event pointer: invalid event Id [{0},{1}] in class [{2}]", classId, memberId, holderClassId);
}
_event = eb.CreateInherited(root);
}
else
{
ClassPointer declarer = ClassPointer.CreateClassPointer(classId, reader.ObjectList.Project);
_event = declarer.GetCustomEventById(memberId);
}
//holder an instance?
object v = reader.ObjectList.GetObjectByID(holderMemberId);
if (v != null)
{
_holder = reader.ObjectList.GetClassRefByObject(v) as IClass;
}
if (_holder == null)
{
//holder is a local variable
//ClassPointer root = reader.ObjectList.GetTypedData<ClassPointer>();
LocalVariable lv = root.GetLocalVariable(holderMemberId);
_holder = lv;
}
}
}
}
}
if (_event == null)
{
throw new DesignerException("Error reading custom event pointer: [{0}]", node.InnerXml);
}
if (_holder == null)
{
throw new DesignerException("Invalid custom event pointer. Holder not found. [{0}]", node.InnerXml);
}
}
void case_948()
#line 6325 "cs-parser.jay"
{
var lt = (LocatedToken) yyVals[0+yyTop];
var li = new LocalVariable (current_block, lt.Value, lt.Location);
current_block.AddLocalName (li);
current_variable = new BlockVariable ((FullNamedExpression) yyVals[-1+yyTop], li);
}
public BooleanExpressionArgCoder Or(LocalVariable variable)
{
this.Or(this.builderType, variable);
return(this);
}
public static TypeMirror GetType(object parent, LocalVariable key)
{
return key.Type;
}
protected override bool DoDefineMembers()
{
PredefinedType builder_type;
PredefinedMember <MethodSpec> bf;
PredefinedMember <MethodSpec> bs;
PredefinedMember <MethodSpec> sr;
PredefinedMember <MethodSpec> se;
PredefinedMember <MethodSpec> sm;
bool has_task_return_type = false;
var pred_members = Module.PredefinedMembers;
if (return_type.Kind == MemberKind.Void)
{
builder_type = Module.PredefinedTypes.AsyncVoidMethodBuilder;
bf = pred_members.AsyncVoidMethodBuilderCreate;
bs = pred_members.AsyncVoidMethodBuilderStart;
sr = pred_members.AsyncVoidMethodBuilderSetResult;
se = pred_members.AsyncVoidMethodBuilderSetException;
sm = pred_members.AsyncVoidMethodBuilderSetStateMachine;
}
else if (return_type == Module.PredefinedTypes.Task.TypeSpec)
{
builder_type = Module.PredefinedTypes.AsyncTaskMethodBuilder;
bf = pred_members.AsyncTaskMethodBuilderCreate;
bs = pred_members.AsyncTaskMethodBuilderStart;
sr = pred_members.AsyncTaskMethodBuilderSetResult;
se = pred_members.AsyncTaskMethodBuilderSetException;
sm = pred_members.AsyncTaskMethodBuilderSetStateMachine;
task = pred_members.AsyncTaskMethodBuilderTask.Get();
}
else
{
builder_type = Module.PredefinedTypes.AsyncTaskMethodBuilderGeneric;
bf = pred_members.AsyncTaskMethodBuilderGenericCreate;
bs = pred_members.AsyncTaskMethodBuilderGenericStart;
sr = pred_members.AsyncTaskMethodBuilderGenericSetResult;
se = pred_members.AsyncTaskMethodBuilderGenericSetException;
sm = pred_members.AsyncTaskMethodBuilderGenericSetStateMachine;
task = pred_members.AsyncTaskMethodBuilderGenericTask.Get();
has_task_return_type = true;
}
set_result = sr.Get();
set_exception = se.Get();
builder_factory = bf.Get();
builder_start = bs.Get();
var istate_machine = Module.PredefinedTypes.IAsyncStateMachine;
var set_statemachine = sm.Get();
if (!builder_type.Define() || !istate_machine.Define() || set_result == null || builder_factory == null ||
set_exception == null || set_statemachine == null || builder_start == null ||
!Module.PredefinedTypes.INotifyCompletion.Define())
{
Report.Error(1993, Location,
"Cannot find compiler required types for asynchronous functions support. Are you targeting the wrong framework version?");
return(base.DoDefineMembers());
}
var bt = builder_type.TypeSpec;
//
// Inflate generic Task types
//
if (has_task_return_type)
{
var task_return_type = return_type.TypeArguments;
if (mutator != null)
{
task_return_type = mutator.Mutate(task_return_type);
}
bt = bt.MakeGenericType(Module, task_return_type);
set_result = MemberCache.GetMember(bt, set_result);
set_exception = MemberCache.GetMember(bt, set_exception);
set_statemachine = MemberCache.GetMember(bt, set_statemachine);
if (task != null)
{
task = MemberCache.GetMember(bt, task);
}
}
builder = AddCompilerGeneratedField("$builder", new TypeExpression(bt, Location));
var set_state_machine = new Method(this, new TypeExpression(Compiler.BuiltinTypes.Void, Location),
Modifiers.COMPILER_GENERATED | Modifiers.DEBUGGER_HIDDEN | Modifiers.PUBLIC,
new MemberName("SetStateMachine"),
ParametersCompiled.CreateFullyResolved(
new Parameter(new TypeExpression(istate_machine.TypeSpec, Location), "stateMachine", Parameter.Modifier.NONE, null, Location),
istate_machine.TypeSpec),
null);
ToplevelBlock block = new ToplevelBlock(Compiler, set_state_machine.ParameterInfo, Location);
block.IsCompilerGenerated = true;
set_state_machine.Block = block;
Members.Add(set_state_machine);
if (!base.DoDefineMembers())
{
return(false);
}
//
// Fabricates SetStateMachine method
//
// public void SetStateMachine (IAsyncStateMachine stateMachine)
// {
// $builder.SetStateMachine (stateMachine);
// }
//
var mg = MethodGroupExpr.CreatePredefined(set_statemachine, bt, Location);
mg.InstanceExpression = new FieldExpr(builder, Location);
var param_reference = block.GetParameterReference(0, Location);
param_reference.Type = istate_machine.TypeSpec;
param_reference.eclass = ExprClass.Variable;
var args = new Arguments(1);
args.Add(new Argument(param_reference));
set_state_machine.Block.AddStatement(new StatementExpression(new Invocation(mg, args)));
if (has_task_return_type)
{
hoisted_return = LocalVariable.CreateCompilerGenerated(bt.TypeArguments[0], StateMachineMethod.Block, Location);
}
return(true);
}
protected override int GetVariableNamePosition (IEditableTextFile file, LocalVariable var)
{
int begin = file.GetPositionFromLineColumn (var.Region.Start.Line, var.Region.Start.Column);
int end = file.GetPositionFromLineColumn (var.Region.Start.Line, var.Region.End.Column);
if (begin == -1 || end == -1)
return -1;
string txt = file.GetText (begin, end);
int i = 0; /* = txt.IndexOf ('=');
if (i == -1)
i = txt.Length;*/
int pos = -1;
do {
i = pos = txt.IndexOf (var.Name, i);
} while ( (pos > 0 && !Char.IsLetter (file.GetCharAt (pos - 1))) &&
(pos + txt.Length + 1 < file.Length )&& !Char.IsLetterOrDigit (file.GetCharAt (pos + txt.Length + 1))
);
if (pos == -1)
return -1;
return begin + pos;
}
protected override Expression DoResolve(ResolveContext rc)
{
var src = source.Resolve(rc);
if (src == null)
{
return(null);
}
if (InternalType.HasNoType(src.Type))
{
rc.Report.Error(8131, source.Location, "Deconstruct assignment requires an expression with a type on the right-hand-side");
return(null);
}
var src_type = src.Type;
if (src_type.IsTupleType)
{
if (src_type.Arity != targetExprs.Count)
{
rc.Report.Error(8132, loc, "Cannot deconstruct a tuple of `{0}' elements into `{1}' variables",
src_type.Arity.ToString(), targetExprs.Count.ToString());
return(null);
}
var tupleLiteral = src as TupleLiteral;
if (tupleLiteral == null && !ExpressionAnalyzer.IsInexpensiveLoad(src))
{
var expr_variable = LocalVariable.CreateCompilerGenerated(source.Type, rc.CurrentBlock, loc);
source = new CompilerAssign(expr_variable.CreateReferenceExpression(rc, loc), source, loc);
instance = expr_variable.CreateReferenceExpression(rc, loc);
}
for (int i = 0; i < targetExprs.Count; ++i)
{
var tle = src_type.TypeArguments [i];
var lv = variablesToInfer? [i];
if (lv != null)
{
if (InternalType.HasNoType(tle))
{
rc.Report.Error(8130, Location, "Cannot infer the type of implicitly-typed deconstruction variable `{0}'", lv.Name);
lv.Type = InternalType.ErrorType;
continue;
}
lv.Type = tle;
lv.PrepareAssignmentAnalysis((BlockContext)rc);
}
var element_src = tupleLiteral == null ? new MemberAccess(instance, NamedTupleSpec.GetElementPropertyName(i)) : tupleLiteral.Elements [i].Expr;
targetExprs [i] = new SimpleAssign(targetExprs [i], element_src).Resolve(rc);
}
eclass = ExprClass.Value;
type = src.Type;
return(this);
}
if (src_type.BuiltinType == BuiltinTypeSpec.Type.Dynamic)
{
rc.Report.Error(8133, loc, "Cannot deconstruct dynamic objects");
return(null);
}
/*
* var args = new Arguments (targetExprs.Count);
* foreach (var t in targetExprs) {
* args.Add (new Argument (t, Argument.AType.Out));
* }
*
* var invocation = new Invocation (new MemberAccess (src, "Deconstruct"), args);
* var res = invocation.Resolve (rc);
*/
throw new NotImplementedException("Custom deconstruct");
}
public RefactorFindVariableReferences(LocalVariable var, MemberReferenceCollection references)
{
this.references = references;
this.var = var;
}
private static List <LocalOperation> BuildLocalOperationsToInline(
MethodInterpreter interpreter, Dictionary <LocalVariable, IdentifierValue> mappedNames, LocalVariable result)
{
var localOperationsToInline = new List <LocalOperation>();
var localOperations = interpreter.MidRepresentation.LocalOperations.ToList();
for (var index = 0; index < localOperations.Count; index++)
{
var localOperation = localOperations[index];
if (localOperation.Kind == OperationKind.Return)
{
HandleReturn(result, localOperationsToInline, localOperation);
break;
}
var clone = localOperation.Clone();
SwitchUsageClones(mappedNames, clone);
localOperationsToInline.Add(clone);
}
return(localOperationsToInline);
}
RefactorerContext GetGeneratorContext(LocalVariable var)
{
return(new RefactorerContext(GetParserContext(var), fileProvider, null));
}
protected override string GetVariableMangledName(LocalVariable local_info)
{
return("<" + local_info.Name + ">__" + local_name_idx++.ToString());
}
public static void Set(ThreadMirror thread, VariableItem item, LiveStackFrame parent, LocalVariable key, Value newValue)
{
parent.SetValue(key, newValue);
}
public BooleanExpressionVariableCoder And(LocalVariable variable)
{
this.And(this.builderType, variable);
return(this);
}
public MemberReferenceCollection FindVariableReferences (IProgressMonitor monitor, LocalVariable var)
{
MemberReferenceCollection refs = new MemberReferenceCollection ();
Refactor (monitor, var, new RefactorDelegate (new RefactorFindVariableReferences (var, refs).Refactor));
return refs;
}
public override LocalVariable VisitLocalVariable(LocalVariable node)
{
add(node);
return(base.VisitLocalVariable(node));
}
RefactorerContext GetGeneratorContext (LocalVariable var)
{
return new RefactorerContext (GetParserContext (var), fileProvider, null);
}
void PredicateImplementation()
{
blockGraph = prog.ProcessLoops(impl);
var sortedBlocks = blockGraph.LoopyTopSort();
int blockId = 0;
foreach (var block in impl.Blocks)
{
blockIds[block] = Expr.Literal(blockId++);
}
returnBlockId = Expr.Literal(blockId++);
curVar = new LocalVariable(Token.NoToken,
new TypedIdent(Token.NoToken, "cur",
Microsoft.Boogie.Type.Int));
impl.LocVars.Add(curVar);
cur = Expr.Ident(curVar);
pVar = new LocalVariable(Token.NoToken,
new TypedIdent(Token.NoToken, "p",
Microsoft.Boogie.Type.Bool));
impl.LocVars.Add(pVar);
p = Expr.Ident(pVar);
if (useProcedurePredicates)
{
fp = Expr.Ident(impl.InParams[0]);
}
var newBlocks = new List <Block>();
Block entryBlock = new Block();
entryBlock.Label = "entry";
entryBlock.Cmds = new List <Cmd> {
Cmd.SimpleAssign(Token.NoToken, cur,
CreateIfFPThenElse(blockIds[sortedBlocks[0].Item1],
returnBlockId))
};
newBlocks.Add(entryBlock);
var prevBlock = entryBlock;
foreach (var n in sortedBlocks)
{
if (n.Item2)
{
var backedgeBlock = new Block();
newBlocks.Add(backedgeBlock);
backedgeBlock.Label = n.Item1.Label + ".backedge";
backedgeBlock.Cmds = new List <Cmd> {
new AssumeCmd(Token.NoToken,
Expr.Eq(cur, blockIds[n.Item1]),
new QKeyValue(Token.NoToken, "backedge", new List <object>(), null))
};
backedgeBlock.TransferCmd = new GotoCmd(Token.NoToken,
new List <Block> {
n.Item1
});
var tailBlock = new Block();
newBlocks.Add(tailBlock);
tailBlock.Label = n.Item1.Label + ".tail";
tailBlock.Cmds = new List <Cmd> {
new AssumeCmd(Token.NoToken,
Expr.Neq(cur, blockIds[n.Item1]))
};
prevBlock.TransferCmd = new GotoCmd(Token.NoToken,
new List <Block> {
backedgeBlock, tailBlock
});
prevBlock = tailBlock;
}
else
{
var runBlock = n.Item1;
var oldCmdSeq = runBlock.Cmds;
runBlock.Cmds = new List <Cmd>();
newBlocks.Add(runBlock);
prevBlock.TransferCmd = new GotoCmd(Token.NoToken,
new List <Block> {
runBlock
});
pExpr = Expr.Eq(cur, blockIds[runBlock]);
if (createCandidateInvariants && blockGraph.Headers.Contains(runBlock))
{
AddUniformCandidateInvariant(runBlock.Cmds, runBlock);
AddNonUniformCandidateInvariant(runBlock.Cmds, runBlock);
}
runBlock.Cmds.Add(Cmd.SimpleAssign(Token.NoToken, p, pExpr));
var transferCmd = runBlock.TransferCmd;
foreach (Cmd cmd in oldCmdSeq)
{
PredicateCmd(newBlocks, runBlock, cmd, out runBlock);
}
PredicateTransferCmd(runBlock.Cmds, transferCmd);
prevBlock = runBlock;
doneBlocks.Add(runBlock);
}
}
prevBlock.TransferCmd = new ReturnCmd(Token.NoToken);
impl.Blocks = newBlocks;
}
IRefactorer GetGeneratorForVariable (LocalVariable var)
{
return LanguageBindingService.GetRefactorerForFile (var.FileName);
}
void PredicateCmd(List <Cmd> cmdSeq, Cmd cmd)
{
if (cmd is AssignCmd)
{
var aCmd = (AssignCmd)cmd;
cmdSeq.Add(new AssignCmd(Token.NoToken, aCmd.Lhss,
new List <Expr>(aCmd.Lhss.Zip(aCmd.Rhss, (lhs, rhs) =>
new NAryExpr(Token.NoToken,
new IfThenElse(Token.NoToken),
new List <Expr> {
p, rhs, lhs.AsExpr
})))));
}
else if (cmd is AssertCmd)
{
var aCmd = (AssertCmd)cmd;
if (cmdSeq.Last() is AssignCmd &&
cmdSeq.Cast <Cmd>().SkipEnd(1).All(c => c is AssertCmd))
{
// This may be a loop invariant. Make sure it continues to appear as
// the first statement in the block.
var assign = cmdSeq.Last();
cmdSeq.RemoveAt(cmdSeq.Count - 1);
Expr newExpr = new EnabledReplacementVisitor(pExpr, null).VisitExpr(aCmd.Expr);
aCmd.Expr = QKeyValue.FindBoolAttribute(aCmd.Attributes, "do_not_predicate") ? newExpr : Expr.Imp(pExpr, newExpr);
cmdSeq.Add(aCmd);
// cmdSeq.Add(new AssertCmd(aCmd.tok, Expr.Imp(pExpr, aCmd.Expr)));
cmdSeq.Add(assign);
}
else
{
aCmd.Expr = Expr.Imp(p, aCmd.Expr);
cmdSeq.Add(aCmd);
// cmdSeq.Add(new AssertCmd(aCmd.tok, Expr.Imp(p, aCmd.Expr)));
}
}
else if (cmd is AssumeCmd)
{
var aCmd = (AssumeCmd)cmd;
cmdSeq.Add(new AssumeCmd(Token.NoToken, Expr.Imp(p, aCmd.Expr)));
}
else if (cmd is HavocCmd)
{
var hCmd = (HavocCmd)cmd;
foreach (IdentifierExpr v in hCmd.Vars)
{
Microsoft.Boogie.Type type = v.Decl.TypedIdent.Type;
Contract.Assert(type != null);
IdentifierExpr havocTempExpr;
if (havocVars.ContainsKey(type))
{
havocTempExpr = havocVars[type];
}
else
{
var havocVar = new LocalVariable(Token.NoToken,
new TypedIdent(Token.NoToken,
"_HAVOC_" + type.ToString(), type));
impl.LocVars.Add(havocVar);
havocVars[type] = havocTempExpr =
new IdentifierExpr(Token.NoToken, havocVar);
}
cmdSeq.Add(new HavocCmd(Token.NoToken,
new List <IdentifierExpr> {
havocTempExpr
}));
cmdSeq.Add(Cmd.SimpleAssign(Token.NoToken, v,
new NAryExpr(Token.NoToken,
new IfThenElse(Token.NoToken),
new List <Expr> {
p, havocTempExpr, v
})));
}
}
else if (cmd is CallCmd)
{
Debug.Assert(useProcedurePredicates);
var cCmd = (CallCmd)cmd;
cCmd.Ins.Insert(0, p);
cmdSeq.Add(cCmd);
}
else if (cmd is CommentCmd)
{
// skip
}
else if (cmd is StateCmd)
{
var sCmd = (StateCmd)cmd;
var newCmdSeq = new List <Cmd>();
foreach (Cmd c in sCmd.Cmds)
{
PredicateCmd(newCmdSeq, c);
}
sCmd.Cmds = newCmdSeq;
cmdSeq.Add(sCmd);
}
else
{
Console.WriteLine("Unsupported cmd: " + cmd.GetType().ToString());
}
}
/// <summary>
/// Gets a local variable reference used in an instruction starting at the given offset, to a variable with given index in the stack frame.
/// </summary>
private LocalVariableReference GetLocalVariable(int instructionOffset, int index, string name, TypeReference type)
{
foreach (var entry in localVariableMap)
{
if (/*entry.Item1.IsValidForOffset(instructionOffset) &&*/ (entry.Item1.Index == index))
{
return entry.Item2;
}
}
// Not found, create a new one
var v = new LocalVariable(0, code.Length, name, type, index);
var varRef = new LocalVariableReference(method, index);
localVariableMap.Add(Tuple.Create(v, varRef));
return varRef;
}
Method GenerateNumberMatcher()
{
var loc = Location;
var parameters = ParametersCompiled.CreateFullyResolved(
new [] {
new Parameter(new TypeExpression(Compiler.BuiltinTypes.Object, loc), "obj", 0, null, loc),
new Parameter(new TypeExpression(Compiler.BuiltinTypes.Object, loc), "value", 0, null, loc),
new Parameter(new TypeExpression(Compiler.BuiltinTypes.Bool, loc), "enumType", 0, null, loc),
},
new [] {
Compiler.BuiltinTypes.Object,
Compiler.BuiltinTypes.Object,
Compiler.BuiltinTypes.Bool
});
var m = new Method(this, new TypeExpression(Compiler.BuiltinTypes.Bool, loc),
Modifiers.PUBLIC | Modifiers.STATIC | Modifiers.DEBUGGER_HIDDEN, new MemberName("NumberMatcher", loc),
parameters, null);
parameters [0].Resolve(m, 0);
parameters [1].Resolve(m, 1);
parameters [2].Resolve(m, 2);
ToplevelBlock top_block = new ToplevelBlock(Compiler, parameters, loc);
m.Block = top_block;
//
// if (enumType)
// return Equals (obj, value);
//
var equals_args = new Arguments(2);
equals_args.Add(new Argument(top_block.GetParameterReference(0, loc)));
equals_args.Add(new Argument(top_block.GetParameterReference(1, loc)));
var if_type = new If(
top_block.GetParameterReference(2, loc),
new Return(new Invocation(new SimpleName("Equals", loc), equals_args), loc),
loc);
top_block.AddStatement(if_type);
//
// if (obj is Enum || obj == null)
// return false;
//
var if_enum = new If(
new Binary(Binary.Operator.LogicalOr,
new Is(top_block.GetParameterReference(0, loc), new TypeExpression(Compiler.BuiltinTypes.Enum, loc), loc),
new Binary(Binary.Operator.Equality, top_block.GetParameterReference(0, loc), new NullLiteral(loc))),
new Return(new BoolLiteral(Compiler.BuiltinTypes, false, loc), loc),
loc);
top_block.AddStatement(if_enum);
var system_convert = new MemberAccess(new QualifiedAliasMember("global", "System", loc), "Convert", loc);
//
// var converted = System.Convert.ChangeType (obj, System.Convert.GetTypeCode (value));
//
var lv_converted = LocalVariable.CreateCompilerGenerated(Compiler.BuiltinTypes.Object, top_block, loc);
var arguments_gettypecode = new Arguments(1);
arguments_gettypecode.Add(new Argument(top_block.GetParameterReference(1, loc)));
var gettypecode = new Invocation(new MemberAccess(system_convert, "GetTypeCode", loc), arguments_gettypecode);
var arguments_changetype = new Arguments(1);
arguments_changetype.Add(new Argument(top_block.GetParameterReference(0, loc)));
arguments_changetype.Add(new Argument(gettypecode));
var changetype = new Invocation(new MemberAccess(system_convert, "ChangeType", loc), arguments_changetype);
top_block.AddStatement(new StatementExpression(new SimpleAssign(new LocalVariableReference(lv_converted, loc), changetype, loc)));
//
// return converted.Equals (value)
//
var equals_arguments = new Arguments(1);
equals_arguments.Add(new Argument(top_block.GetParameterReference(1, loc)));
var equals_invocation = new Invocation(new MemberAccess(new LocalVariableReference(lv_converted, loc), "Equals"), equals_arguments);
top_block.AddStatement(new Return(equals_invocation, loc));
m.Define();
m.PrepareEmit();
AddMember(m);
return(m);
}
void case_523()
#line 3843 "cs-parser.jay"
{
if (lang_version != LanguageVersion.Experimental)
FeatureIsNotAvailable (GetLocation (yyVals[-3+yyTop]), "declaration expression");
var lt = (LocatedToken) yyVals[-2+yyTop];
var lv = new LocalVariable (current_block, lt.Value, lt.Location);
current_block.AddLocalName (lv);
yyVal = new DeclarationExpression ((FullNamedExpression) yyVals[-3+yyTop], lv) {
Initializer = (Expression) yyVals[0+yyTop]
};
}
public override LocalVariable VisitLocalVariable(LocalVariable node)
{
//Contract.Requires(node != null);
Contract.Ensures(Contract.Result <LocalVariable>() != null);
return(base.VisitLocalVariable((LocalVariable)node.Clone()));
}
void case_875()
#line 5886 "cs-parser.jay"
{
var lt = (LocatedToken) yyVals[0+yyTop];
var li = new LocalVariable (current_block, lt.Value, LocalVariable.Flags.Constant, lt.Location);
current_block.AddLocalName (li);
current_variable = new BlockConstant ((FullNamedExpression) yyVals[-1+yyTop], li);
}
public string Visit(LocalVariable var, OutputSettings settings)
{
return(settings.EmitName(var, FilterName(var.Name)));
}
void case_896()
#line 5999 "cs-parser.jay"
{
var lt = (LocatedToken) yyVals[-2+yyTop];
var li = new LocalVariable (current_block, lt.Value, LocalVariable.Flags.Constant, lt.Location);
var d = new BlockVariableDeclarator (li, (Expression) yyVals[0+yyTop]);
current_variable.AddDeclarator (d);
current_block.AddLocalName (li);
lbag.AddLocation (d, GetLocation (yyVals[-3+yyTop]), GetLocation (yyVals[-1+yyTop]));
}
internal static void localvar_location(this TextWriter trapFile, LocalVariable var, Location location)
{
trapFile.WriteTuple("localvar_location", var, location);
}
void case_959()
#line 6389 "cs-parser.jay"
{
Error_SyntaxError (yyToken);
start_block (GetLocation (yyVals[-3+yyTop]));
current_block.IsCompilerGenerated = true;
var lt = (LocatedToken) yyVals[-1+yyTop];
var li = new LocalVariable (current_block, lt.Value, LocalVariable.Flags.ForeachVariable | LocalVariable.Flags.Used, lt.Location);
current_block.AddLocalName (li);
Foreach f = new Foreach ((Expression) yyVals[-2+yyTop], li, null, null, null, GetLocation (yyVals[-4+yyTop]));
current_block.AddStatement (f);
lbag.AddStatement (f, GetLocation (yyVals[-3+yyTop]));
yyVal = end_block (GetLocation (yyVals[0+yyTop]));
}
internal static void localvars(this TextWriter trapFile, LocalVariable key, int @const, string name, int @var, Type type, Expression expr)
{
trapFile.WriteTuple("localvars", key, @const, name, @var, type, expr);
}
void case_1013()
#line 6784 "cs-parser.jay"
{
start_block (GetLocation (yyVals[-2+yyTop]));
current_block.IsCompilerGenerated = true;
var lt = (LocatedToken) yyVals[0+yyTop];
var li = new LocalVariable (current_block, lt.Value, LocalVariable.Flags.UsingVariable | LocalVariable.Flags.Used, lt.Location);
current_block.AddLocalName (li);
current_variable = new Using.VariableDeclaration ((FullNamedExpression) yyVals[-1+yyTop], li);
}
public override bool check(CodeContext context)
{
if (is_checked)
{
return(!error);
}
is_checked = true;
if (member_name != null)
{
if (!member_name.check(context))
{
error = true;
return(false);
}
}
TypeSymbol type = null;
if (type_reference == null)
{
if (member_name == null)
{
error = true;
Report.error(source_reference, "Incomplete object creation expression");
return(false);
}
if (member_name.symbol_reference == null)
{
error = true;
return(false);
}
var constructor_sym = member_name.symbol_reference;
var type_sym = member_name.symbol_reference;
var type_args = member_name.get_type_arguments();
if (constructor_sym is Method)
{
type_sym = constructor_sym.parent_symbol;
var constructor = (Method)constructor_sym;
if (!(constructor_sym is CreationMethod))
{
error = true;
Report.error(source_reference, "`%s' is not a creation method".printf(constructor.get_full_name()));
return(false);
}
symbol_reference = constructor;
// inner expression can also be base access when chaining constructors
var ma = member_name.inner as MemberAccess;
if (ma != null)
{
type_args = ma.get_type_arguments();
}
}
if (type_sym is Class)
{
type = (TypeSymbol)type_sym;
if (((Class)type).is_error_base)
{
type_reference = new ErrorType(null, null, source_reference);
}
else
{
type_reference = new ObjectType((Class)type);
}
}
else if (type_sym is Struct)
{
type = (TypeSymbol)type_sym;
type_reference = new StructValueType((Struct)type);
}
else if (type_sym is ErrorCode)
{
type_reference = new ErrorType((ErrorDomain)type_sym.parent_symbol, (ErrorCode)type_sym, source_reference);
symbol_reference = type_sym;
}
else
{
error = true;
Report.error(source_reference, "`%s' is not a class, struct, or error code".printf(type_sym.get_full_name()));
return(false);
}
foreach (DataType type_arg in type_args)
{
type_reference.add_type_argument(type_arg);
}
}
else
{
type = type_reference.data_type;
}
value_type = type_reference.copy();
value_type.value_owned = true;
bool may_throw = false;
int given_num_type_args = type_reference.get_type_arguments().Count;
int expected_num_type_args = 0;
if (type is Class)
{
var cl = (Class)type;
expected_num_type_args = cl.get_type_parameters().Count;
if (struct_creation)
{
error = true;
Report.error(source_reference, "syntax error, use `new' to create new objects");
return(false);
}
if (cl.is_abstract)
{
value_type = null;
error = true;
Report.error(source_reference, "Can't create instance of abstract class `%s'".printf(cl.get_full_name()));
return(false);
}
if (symbol_reference == null)
{
symbol_reference = cl.default_construction_method;
if (symbol_reference == null)
{
error = true;
Report.error(source_reference, "`%s' does not have a default constructor".printf(cl.get_full_name()));
return(false);
}
// track usage for flow analyzer
symbol_reference.used = true;
symbol_reference.version.check(source_reference);
}
if (symbol_reference != null &&
(symbol_reference.access == SymbolAccessibility.PRIVATE || symbol_reference.access == SymbolAccessibility.PROTECTED))
{
bool in_target_type = false;
for (Symbol this_symbol = context.analyzer.current_symbol; this_symbol != null; this_symbol = this_symbol.parent_symbol)
{
if (this_symbol == cl)
{
in_target_type = true;
break;
}
}
if (!in_target_type)
{
error = true;
Report.error(source_reference, "Access to non-public constructor `%s' denied".printf(symbol_reference.get_full_name()));
return(false);
}
}
while (cl != null)
{
// FIXME: use target values in the codegen
if (cl.get_attribute_string("CCode", "ref_sink_function") != null)
{
value_type.floating_reference = true;
break;
}
cl = cl.base_class;
}
}
else if (type is Struct)
{
var st = (Struct)type;
expected_num_type_args = st.get_type_parameters().Count;
if (!struct_creation && !context.deprecated)
{
Report.warning(source_reference, "deprecated syntax, don't use `new' to initialize structs");
}
if (symbol_reference == null)
{
symbol_reference = st.default_construction_method;
}
if (st.is_simple_type() && symbol_reference == null && object_initializer.Count == 0)
{
error = true;
Report.error(source_reference, "`%s' does not have a default constructor".printf(st.get_full_name()));
return(false);
}
}
if (expected_num_type_args > given_num_type_args)
{
error = true;
Report.error(source_reference, "too few type arguments");
return(false);
}
else if (expected_num_type_args < given_num_type_args)
{
error = true;
Report.error(source_reference, "too many type arguments");
return(false);
}
if (symbol_reference == null && get_argument_list().Count != 0)
{
value_type = null;
error = true;
Report.error(source_reference, "No arguments allowed when constructing type `%s'".printf(type.get_full_name()));
return(false);
}
if (symbol_reference is Method)
{
var m = (Method)symbol_reference;
if (is_yield_expression)
{
if (!m.coroutine)
{
error = true;
Report.error(source_reference, "yield expression requires async method");
}
if (context.analyzer.current_method == null || !context.analyzer.current_method.coroutine)
{
error = true;
Report.error(source_reference, "yield expression not available outside async method");
}
}
// FIXME partial code duplication of MethodCall.check
Expression last_arg = null;
var args = get_argument_list();
IEnumerator <Expression> arg_it = args.GetEnumerator();
foreach (Parameter param in m.get_parameters())
{
if (param.ellipsis)
{
break;
}
if (arg_it.MoveNext())
{
Expression arg = arg_it.Current;
/* store expected type for callback parameters */
arg.formal_target_type = param.variable_type;
arg.target_type = arg.formal_target_type.get_actual_type(value_type, null, this);
last_arg = arg;
}
}
// printf arguments
if (m.printf_format)
{
StringLiteral format_literal = null;
if (last_arg != null)
{
// use last argument as format string
format_literal = StringLiteral.get_format_literal(last_arg);
if (format_literal == null && args.Count == m.get_parameters().Count - 1)
{
// insert "%s" to avoid issues with embedded %
format_literal = new StringLiteral("\"%s\"");
format_literal.target_type = context.analyzer.string_type.copy();
argument_list.Insert(args.Count - 1, format_literal);
// recreate iterator and skip to right position
arg_it = argument_list.GetEnumerator();
foreach (Parameter param in m.get_parameters())
{
if (param.ellipsis)
{
break;
}
arg_it.MoveNext();
}
}
}
if (format_literal != null)
{
string format = format_literal.eval();
if (!context.analyzer.check_print_format(format, arg_it, source_reference))
{
return(false);
}
}
}
foreach (Expression arg in args.ToList())
{
arg.check(context);
}
context.analyzer.check_arguments(this, new MethodType(m), m.get_parameters(), args);
foreach (DataType error_type in m.get_error_types())
{
may_throw = true;
// ensure we can trace back which expression may throw errors of this type
var call_error_type = error_type.copy();
call_error_type.source_reference = source_reference;
add_error_type(call_error_type);
}
}
else if (type_reference is ErrorType)
{
if (type_reference != null)
{
type_reference.check(context);
}
if (member_name != null)
{
member_name.check(context);
}
foreach (Expression arg in argument_list)
{
arg.check(context);
}
foreach (MemberInitializer init in object_initializer)
{
init.check(context);
}
if (get_argument_list().Count == 0)
{
error = true;
Report.error(source_reference, "Too few arguments, errors need at least 1 argument");
}
else
{
IEnumerator <Expression> arg_it = get_argument_list().GetEnumerator();
arg_it.MoveNext();
var ex = arg_it.Current;
if (ex.value_type == null || !ex.value_type.compatible(context.analyzer.string_type))
{
error = true;
Report.error(source_reference, "Invalid type for argument 1");
}
var format_literal = StringLiteral.get_format_literal(ex);
if (format_literal != null)
{
var format = format_literal.eval();
if (!context.analyzer.check_print_format(format, arg_it, source_reference))
{
error = true;
return(false);
}
}
arg_it = get_argument_list().GetEnumerator();
arg_it.MoveNext();
if (!context.analyzer.check_variadic_arguments(arg_it, 1, source_reference))
{
error = true;
return(false);
}
}
}
foreach (MemberInitializer init in get_object_initializer())
{
context.analyzer.visit_member_initializer(init, type_reference);
}
if (may_throw)
{
if (parent_node is LocalVariable || parent_node is ExpressionStatement)
{
// simple statements, no side effects after method call
}
else if (!(context.analyzer.current_symbol is Block))
{
// can't handle errors in field initializers
Report.error(source_reference, "Field initializers must not throw errors");
}
else
{
// store parent_node as we need to replace the expression in the old parent node later on
var old_parent_node = parent_node;
var local = new LocalVariable(value_type.copy(), get_temp_name(), null, source_reference);
var decl = new DeclarationStatement(local, source_reference);
insert_statement(context.analyzer.insert_block, decl);
var temp_access = SemanticAnalyzer.create_temp_access(local, target_type);
// don't set initializer earlier as this changes parent_node and parent_statement
local.initializer = this;
decl.check(context);
// move temp variable to insert block to ensure the
// variable is in the same block as the declaration
// otherwise there will be scoping issues in the generated code
var block = (Block)context.analyzer.current_symbol;
block.remove_local_variable(local);
context.analyzer.insert_block.add_local_variable(local);
old_parent_node.replace_expression(this, temp_access);
temp_access.check(context);
}
}
return(!error);
}
public LocalVariableResolveResult (LocalVariable variable) : this (variable, false)
{
}
public Tuple <DependencyPTGDomain, TimeSpan> AnalyzeMoveNextMethod()
{
AnalysisStats.extraAnalysisOverHead = new Stopwatch();
var sw = new Stopwatch();
sw.Start();
// 0) Analyze static fields.
// DIEGODIEGO: Should I also Include the points-to graph???
var staticConstructor = processToAnalyze.ProcessorClass.Methods.SingleOrDefault(m => m.Name.Value == ".cctor");
if (staticConstructor != null)
{
var cfgcCtor = staticConstructor.DoAnalysisPhases(host, sourceLocationProvider);
var rangeAnalysisCctor = new RangeAnalysis(cfgcCtor, staticConstructor);
rangeAnalysisCctor.Analyze();
}
// The following steps generates a PTG for the MoveNext method that takes into account the context of invocation
// This is the Producer entry method and the call to GetEnumerator which then is used in the Movenext method
// 1) Analyze the entry method that creates, populates and return the clousure
var cfgEntry = processToAnalyze.EntryMethod.DoAnalysisPhases(host, sourceLocationProvider);
var pointsToEntry = new SimplePointsToAnalysis(cfgEntry, processToAnalyze.EntryMethod);
var entryResult = pointsToEntry.Analyze();
var ptgOfEntry = entryResult[cfgEntry.Exit.Id].Output;
// 2) Call the GetEnumerator that may create a new clousure and polulate it
var myGetEnumResult = new LocalVariable("$_temp_it", processToAnalyze.EntryMethod)
{
Type = processToAnalyze.GetIteratorMethod.Type
};
ptgOfEntry.Add(myGetEnumResult);
var ptgAfterEnum = this.interprocManager.PTAInterProcAnalysis(ptgOfEntry, new List <IVariable> {
pointsToEntry.ReturnVariable
}, myGetEnumResult, processToAnalyze.GetIteratorMethod);
// These are the nodes that we want to protect/analyze
var protectedNodes = ptgOfEntry.Nodes.OfType <ParameterNode>()
.Where(n => IsScopeType(n.Type)).Select(n => new ProtectedRowNode(n, ProtectedRowNode.GetKind(n.Type)));
// Create tables representing the input and output tables
this.inputTable = new TraceableTable(protectedNodes.Single(pn => pn.RowKind == ProtectedRowKind.Input));
this.outputTable = new TraceableTable(protectedNodes.Single(pn => pn.RowKind == ProtectedRowKind.Output));
// 3) I bing the current PTG with the parameters of MoveNext method on the clousure
// Well... Inlining is broken we we added the Exceptional control graph. Let's avoid it
//var cfg = this.moveNextMethod.DoAnalysisPhases(host, this.GetMethodsToInline());
var cfg = this.interprocManager.GetCFG(processToAnalyze.MoveNextMethod);
cfg.PropagateExpressions(this.equalities);
// In general, the variable to bind is going to be pointsToEntry.ReturnVariable which is aliased with "$_temp_it" (myGetEnumResult)
SimplePointsToGraph calleePTG = InterproceduralManager.PTABindCallerCallee(ptgAfterEnum, new List <IVariable> {
myGetEnumResult
}, processToAnalyze.MoveNextMethod);
this.pointsToAnalyzer = new SimplePointsToAnalysis(cfg, processToAnalyze.MoveNextMethod, calleePTG);
// Now I analyze the Movenext method with the proper initialization
var result = this.AnalyzeScopeMethod(cfg, pointsToAnalyzer, protectedNodes);
sw.Stop();
//return Tuple.Create(result, sw.Elapsed - AnalysisStats.extraAnalysisOverHead.Elapsed);
return(Tuple.Create(result, sw.Elapsed));
}
public override IEnumerable<MemberReference> FindVariableReferences (RefactorerContext ctx, string fileName, LocalVariable var)
{
var editor = ((Mono.TextEditor.ITextEditorDataProvider)ctx.GetFile (fileName)).GetTextEditorData ();
NRefactoryResolver resolver = new NRefactoryResolver (ctx.ParserContext, var.CompilationUnit, ICSharpCode.NRefactory.SupportedLanguage.CSharp, editor, fileName);
resolver.CallingMember = var.DeclaringMember;
FindMemberAstVisitor visitor = new FindMemberAstVisitor (editor.Document, resolver, var);
visitor.RunVisitor ();
SetContext (visitor.FoundReferences, ctx);
return visitor.FoundReferences;
}
public VarInfo(LocalVariable v, MetadataReader pdbReader)
{
this.Name = pdbReader.GetString(v.Name);
this.Index = v.Index;
}
public override IEnumerable<MemberReference> FindVariableReferences (RefactorerContext ctx, string fileName, LocalVariable var)
{
//System.Console.WriteLine("Find variable references !!!");
// ParsedDocument parsedDocument = ProjectDomService.ParseFile (fileName);
NRefactoryResolver resolver = new NRefactoryResolver (ctx.ParserContext, var.CompilationUnit, ICSharpCode.NRefactory.SupportedLanguage.CSharp, null, fileName);
resolver.CallingMember = var.DeclaringMember;
FindMemberAstVisitor visitor = new FindMemberAstVisitor (resolver, ctx.GetFile (fileName), var);
visitor.RunVisitor ();
SetContext (visitor.FoundReferences, ctx);
return visitor.FoundReferences;
}
public void CaptureLocalVariable (ResolveContext ec, LocalVariable localVariable)
{
if (this is StateMachine) {
if (ec.CurrentBlock.ParametersBlock != localVariable.Block.ParametersBlock)
ec.CurrentBlock.Explicit.HasCapturedVariable = true;
} else {
ec.CurrentBlock.Explicit.HasCapturedVariable = true;
}
var hoisted = localVariable.HoistedVariant;
if (hoisted != null && hoisted.Storey != this && hoisted.Storey is StateMachine) {
//
// Variable is already hoisted but we need it in storey which can be shared
//
hoisted.Storey.hoisted_locals.Remove (hoisted);
hoisted.Storey.Members.Remove (hoisted.Field);
hoisted = null;
}
if (hoisted == null) {
hoisted = new HoistedLocalVariable (this, localVariable, GetVariableMangledName (localVariable));
localVariable.HoistedVariant = hoisted;
if (hoisted_locals == null)
hoisted_locals = new List<HoistedVariable> ();
hoisted_locals.Add (hoisted);
}
if (ec.CurrentBlock.Explicit != localVariable.Block.Explicit && !(hoisted.Storey is StateMachine) && hoisted.Storey != null)
hoisted.Storey.AddReferenceFromChildrenBlock (ec.CurrentBlock.Explicit);
}
