public void SimpleAddressOfExpressionTest()
{
AddressOfExpression ae = ParseUtil.ParseExpression <AddressOfExpression>("AddressOf t");
Assert.IsNotNull(ae);
Assert.IsInstanceOf(typeof(IdentifierExpression), ae.Expression);
Assert.AreEqual("t", ((IdentifierExpression)ae.Expression).Identifier, "t");
}
public virtual object VisitAddressOfExpression(AddressOfExpression addressOfExpression, object data) {
Debug.Assert((addressOfExpression != null));
Debug.Assert((addressOfExpression.Expression != null));
nodeStack.Push(addressOfExpression.Expression);
addressOfExpression.Expression.AcceptVisitor(this, data);
addressOfExpression.Expression = ((Expression)(nodeStack.Pop()));
return null;
}
public virtual object Visit(AddressOfExpression addressOfExpression, object data)
{
Debug.Assert(addressOfExpression != null);
Debug.Assert(addressOfExpression.Expression != null);
addressOfExpression.Expression.AcceptVisitor(this, data);
return(data);
}
public void MemberReferenceAddressOfExpressionTest()
{
AddressOfExpression ae = ParseUtil.ParseExpression <AddressOfExpression>("AddressOf Me.t(Of X)");
Assert.IsNotNull(ae);
Assert.IsInstanceOf(typeof(MemberReferenceExpression), ae.Expression);
Assert.AreEqual("t", ((MemberReferenceExpression)ae.Expression).MemberName, "t");
Assert.IsInstanceOf(typeof(ThisReferenceExpression), ((MemberReferenceExpression)ae.Expression).TargetObject);
}
public void GenericAddressOfExpressionTest()
{
AddressOfExpression ae = ParseUtil.ParseExpression <AddressOfExpression>("AddressOf t(Of X)");
Assert.IsNotNull(ae);
Assert.IsInstanceOf(typeof(IdentifierExpression), ae.Expression);
Assert.AreEqual("t", ((IdentifierExpression)ae.Expression).Identifier, "t");
Assert.AreEqual(1, ((IdentifierExpression)ae.Expression).TypeArguments.Count);
Assert.AreEqual("X", ((IdentifierExpression)ae.Expression).TypeArguments[0].Type);
}
public override object VisitAddressOfExpression(AddressOfExpression addressOfExpression, object data)
{
bool oldValue = resolver.allowMethodGroupResolveResult;
resolver.allowMethodGroupResolveResult = true;
object result = base.VisitAddressOfExpression(addressOfExpression, data);
resolver.allowMethodGroupResolveResult = oldValue;
return(result);
}
/// <summary>
/// При срещане на метод с out параметър, записваме стойност, чрез която ще се игнорира
/// евентуална декларация при срещане на първо присвояване.
/// </summary>
/// <param name="node">Текущ връх</param>
/// <returns>Обработен връх</returns>
public override ICodeNode VisitAddressOfExpression(AddressOfExpression node)
{
VariableReferenceExpression varRefExp = node.Expression as VariableReferenceExpression;
if (varRefExp != null)
{
VariableDefinition varDef = varRefExp.Variable.Resolve();
if (firstAssignment[varDef].assignExpression == null)
{
firstAssignment[varDef] = ignoreFirstAssignment;
}
}
return(base.VisitAddressOfExpression(node));
}
// ExpressionStatement, LockStatement can not be the parent of an IdentifierExpression
public override object VisitAddressOfExpression(AddressOfExpression expression, object data)
{
// Console.WriteLine ("AddressOfExpression");
IntegrateTemporaryVariableVisitorOptions options = (IntegrateTemporaryVariableVisitorOptions)data;
if (IsExpressionToReplace(expression.Expression, options))
{
// in this Case the integration is not valid
throw new IntegrateTemporaryVariableAddressOfException();
}
else
{
return(base.VisitAddressOfExpression(expression, data));
}
}
public sealed override object VisitAddressOfExpression(AddressOfExpression addressOfExpression, object data) {
BeginVisit(addressOfExpression);
object result = TrackedVisitAddressOfExpression(addressOfExpression, data);
EndVisit(addressOfExpression);
return result;
}
public virtual object VisitAddressOfExpression(AddressOfExpression addressOfExpression, object data)
{
throw new global::System.NotImplementedException("AddressOfExpression");
}
public override void VisitAddressOfExpression(AddressOfExpression node)
{
WriteToken("&");
Visit(node.Expression);
}
public virtual object VisitAddressOfExpression(AddressOfExpression addressOfExpression, object data) {
Debug.Assert((addressOfExpression != null));
Debug.Assert((addressOfExpression.Expression != null));
return addressOfExpression.Expression.AcceptVisitor(this, data);
}
public object VisitAddressOfExpression(AddressOfExpression addressOfExpression, object data)
{
throw new NotImplementedException();
}
private bool IsMatch(AddressOfExpression right, AddressOfExpression left)
{
return(false);
}
public virtual object VisitAddressOfExpression(AddressOfExpression addressOfExpression, object data) {
throw new global::System.NotImplementedException("AddressOfExpression");
}
public virtual object TrackedVisitAddressOfExpression(AddressOfExpression addressOfExpression, object data) {
return base.VisitAddressOfExpression(addressOfExpression, data);
}
public override object Visit(AddressOfExpression addressOfExpression, object data)
{
return(addressOfExpression.Expression.AcceptVisitor(this, data));
}
/// <summary>
/// Reads an unsafe access expression.
/// </summary>
/// <param name="parentProxy">Represents the parent item.</param>
/// <param name="unsafeCode">Indicates whether the code being parsed resides in an unsafe code block.</param>
/// <returns>Returns the expression.</returns>
private UnsafeAccessExpression GetUnsafeAccessExpression(CodeUnitProxy parentProxy, bool unsafeCode)
{
Param.AssertNotNull(parentProxy, "parentProxy");
Param.Assert(unsafeCode == true, "unsafeCode", "Unsafe access must reside in an unsafe code block.");
this.AdvanceToNextCodeSymbol(parentProxy);
var expressionProxy = new CodeUnitProxy(this.document);
// Get the operator symbol.
Symbol symbol = this.PeekNextSymbol();
OperatorType operatorType;
if (symbol.SymbolType == SymbolType.LogicalAnd)
{
operatorType = OperatorType.AddressOf;
}
else if (symbol.SymbolType == SymbolType.Multiplication)
{
operatorType = OperatorType.Dereference;
}
else
{
CsLanguageService.Debug.Fail("Unexpected operator type.");
throw new InvalidOperationException();
}
// Create a token for the operator symbol.
this.GetOperatorSymbolToken(expressionProxy, operatorType);
// Get the expression being accessed.
Expression innerExpression = this.GetNextExpression(expressionProxy, ExpressionPrecedence.Unary, unsafeCode);
if (innerExpression == null || innerExpression.Children.Count == 0)
{
throw new SyntaxException(this.document, symbol.LineNumber);
}
// Create and return the expression.
UnsafeAccessExpression expression = null;
if (operatorType == OperatorType.Dereference)
{
expression = new DereferenceExpression(expressionProxy, innerExpression);
}
else
{
expression = new AddressOfExpression(expressionProxy, innerExpression);
}
parentProxy.Children.Add(expression);
return expression;
}
public object VisitAddressOfExpression(AddressOfExpression addressOfExpression, object data)
{
// Boo can reference methods directly
return(ConvertExpression(addressOfExpression.Expression));
}
public override object VisitAddressOfExpression(AddressOfExpression addressOfExpression, object data)
{
return(base.VisitAddressOfExpression(addressOfExpression, data));
}
void SimpleNonInvocationExpression(
#line 1645 "VBNET.ATG"
out Expression pexpr) {
#line 1647 "VBNET.ATG"
Expression expr;
TypeReference type = null;
string name = String.Empty;
pexpr = null;
if (StartOf(32)) {
switch (la.kind) {
case 3: {
lexer.NextToken();
#line 1655 "VBNET.ATG"
pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };
break;
}
case 4: {
lexer.NextToken();
#line 1656 "VBNET.ATG"
pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };
break;
}
case 7: {
lexer.NextToken();
#line 1657 "VBNET.ATG"
pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };
break;
}
case 6: {
lexer.NextToken();
#line 1658 "VBNET.ATG"
pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };
break;
}
case 5: {
lexer.NextToken();
#line 1659 "VBNET.ATG"
pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };
break;
}
case 9: {
lexer.NextToken();
#line 1660 "VBNET.ATG"
pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };
break;
}
case 8: {
lexer.NextToken();
#line 1661 "VBNET.ATG"
pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };
break;
}
case 202: {
lexer.NextToken();
#line 1663 "VBNET.ATG"
pexpr = new PrimitiveExpression(true, "true");
break;
}
case 109: {
lexer.NextToken();
#line 1664 "VBNET.ATG"
pexpr = new PrimitiveExpression(false, "false");
break;
}
case 151: {
lexer.NextToken();
#line 1665 "VBNET.ATG"
pexpr = new PrimitiveExpression(null, "null");
break;
}
case 25: {
lexer.NextToken();
Expr(
#line 1666 "VBNET.ATG"
out expr);
Expect(26);
#line 1666 "VBNET.ATG"
pexpr = new ParenthesizedExpression(expr);
break;
}
case 2: case 45: case 49: case 51: case 52: case 53: case 54: case 57: case 74: case 85: case 91: case 94: case 103: case 108: case 113: case 120: case 126: case 130: case 133: case 156: case 162: case 169: case 188: case 197: case 198: case 208: case 209: case 215: {
Identifier();
#line 1668 "VBNET.ATG"
pexpr = new IdentifierExpression(t.val);
pexpr.StartLocation = t.Location; pexpr.EndLocation = t.EndLocation;
if (
#line 1671 "VBNET.ATG"
la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
lexer.NextToken();
Expect(155);
TypeArgumentList(
#line 1672 "VBNET.ATG"
((IdentifierExpression)pexpr).TypeArguments);
Expect(26);
}
break;
}
case 55: case 58: case 69: case 86: case 87: case 96: case 128: case 137: case 154: case 181: case 186: case 187: case 193: case 206: case 207: case 210: {
#line 1674 "VBNET.ATG"
string val = String.Empty;
if (StartOf(11)) {
PrimitiveTypeName(
#line 1675 "VBNET.ATG"
out val);
} else if (la.kind == 154) {
lexer.NextToken();
#line 1675 "VBNET.ATG"
val = "System.Object";
} else SynErr(257);
#line 1676 "VBNET.ATG"
pexpr = new TypeReferenceExpression(new TypeReference(val, true));
break;
}
case 139: {
lexer.NextToken();
#line 1677 "VBNET.ATG"
pexpr = new ThisReferenceExpression();
break;
}
case 144: case 145: {
#line 1678 "VBNET.ATG"
Expression retExpr = null;
if (la.kind == 144) {
lexer.NextToken();
#line 1679 "VBNET.ATG"
retExpr = new BaseReferenceExpression();
} else if (la.kind == 145) {
lexer.NextToken();
#line 1680 "VBNET.ATG"
retExpr = new ClassReferenceExpression();
} else SynErr(258);
Expect(16);
IdentifierOrKeyword(
#line 1682 "VBNET.ATG"
out name);
#line 1682 "VBNET.ATG"
pexpr = new MemberReferenceExpression(retExpr, name);
break;
}
case 117: {
lexer.NextToken();
Expect(16);
Identifier();
#line 1684 "VBNET.ATG"
type = new TypeReference(t.val ?? "");
#line 1686 "VBNET.ATG"
type.IsGlobal = true;
#line 1687 "VBNET.ATG"
pexpr = new TypeReferenceExpression(type);
break;
}
case 148: {
ObjectCreateExpression(
#line 1688 "VBNET.ATG"
out expr);
#line 1688 "VBNET.ATG"
pexpr = expr;
break;
}
case 81: case 93: case 204: {
#line 1690 "VBNET.ATG"
CastType castType = CastType.Cast;
if (la.kind == 93) {
lexer.NextToken();
} else if (la.kind == 81) {
lexer.NextToken();
#line 1692 "VBNET.ATG"
castType = CastType.Conversion;
} else if (la.kind == 204) {
lexer.NextToken();
#line 1693 "VBNET.ATG"
castType = CastType.TryCast;
} else SynErr(259);
Expect(25);
Expr(
#line 1695 "VBNET.ATG"
out expr);
Expect(12);
TypeName(
#line 1695 "VBNET.ATG"
out type);
Expect(26);
#line 1696 "VBNET.ATG"
pexpr = new CastExpression(type, expr, castType);
break;
}
case 63: case 64: case 65: case 66: case 67: case 68: case 70: case 72: case 73: case 77: case 78: case 79: case 80: case 82: case 83: case 84: {
CastTarget(
#line 1697 "VBNET.ATG"
out type);
Expect(25);
Expr(
#line 1697 "VBNET.ATG"
out expr);
Expect(26);
#line 1697 "VBNET.ATG"
pexpr = new CastExpression(type, expr, CastType.PrimitiveConversion);
break;
}
case 44: {
lexer.NextToken();
Expr(
#line 1698 "VBNET.ATG"
out expr);
#line 1698 "VBNET.ATG"
pexpr = new AddressOfExpression(expr);
break;
}
case 116: {
lexer.NextToken();
Expect(25);
GetTypeTypeName(
#line 1699 "VBNET.ATG"
out type);
Expect(26);
#line 1699 "VBNET.ATG"
pexpr = new TypeOfExpression(type);
break;
}
case 205: {
lexer.NextToken();
SimpleExpr(
#line 1700 "VBNET.ATG"
out expr);
Expect(131);
TypeName(
#line 1700 "VBNET.ATG"
out type);
#line 1700 "VBNET.ATG"
pexpr = new TypeOfIsExpression(expr, type);
break;
}
case 122: {
ConditionalExpression(
#line 1701 "VBNET.ATG"
out pexpr);
break;
}
}
} else if (la.kind == 16) {
lexer.NextToken();
IdentifierOrKeyword(
#line 1705 "VBNET.ATG"
out name);
#line 1705 "VBNET.ATG"
pexpr = new MemberReferenceExpression(null, name);
} else SynErr(260);
}
public override object VisitAddressOfExpression(AddressOfExpression addressOfExpression, object data)
{
return addressOfExpression.Expression.AcceptVisitor(this, data);
}
