Beispiel #1
0
 public virtual void VisitIsExpression(IsExpression isExpression)
 {
     if (this.ThrowException)
     {
         throw (System.Exception) this.CreateException(isExpression);
     }
 }
        /// <summary>
        /// http://dlang.org/expression.html#IsExpression
        /// </summary>
        public ISemantic E(IsExpression isExpression)
        {
            if(!eval)
                return new PrimitiveType(DTokens.Bool);

            bool retTrue = false;

            if (isExpression.TestedType != null)
            {
                var typeToCheck = DResolver.StripMemberSymbols(TypeDeclarationResolver.ResolveSingle(isExpression.TestedType, ctxt));

                if (typeToCheck != null)
                {
                    // case 1, 4
                    if (isExpression.TypeSpecialization == null && isExpression.TypeSpecializationToken == 0)
                        retTrue = true;

                    // The probably most frequented usage of this expression
                    else if (isExpression.TypeAliasIdentifierHash == 0)
                        retTrue = evalIsExpression_NoAlias(isExpression, typeToCheck);
                    else
                        retTrue = evalIsExpression_WithAliases(isExpression, typeToCheck);
                }
            }

            return new PrimitiveValue(DTokens.Bool, retTrue?1:0, isExpression);
        }
Beispiel #3
0
 public virtual void VisitIsExpression(IsExpression isExpression)
 {
     if (ThrowException)
     {
         throw (Exception)CreateException(isExpression);
     }
 }
Beispiel #4
0
        public override object VisitIsExpression(IsExpression isExpression, CSharpAstResolver astResolver)
        {
            ResolveResult resolveResult = astResolver.Resolve(isExpression.Type);

            if (resolveResult != null)
            {
                Tree.Tree t = SourceImporter.SourceImporter.Tree;

                //1) target node
                ClassNode targetNode = new ClassNode(resolveResult.Type.FullName, resolveResult);
                targetNode = t.AddOrGetClassNode(resolveResult.Type.Namespace, targetNode);//override if already in tree with that node

                if (targetNode != null)
                {
                    //2) caller node (can't be null)
                    //find out class in which the invocation statement is found
                    TypeDeclaration classDeclaration = isExpression.Ancestors.Where(a => a is TypeDeclaration).Cast <TypeDeclaration>().First();
                    //resolve the class declaration
                    TypeResolveResult resolvedClass = astResolver.Resolve(classDeclaration) as TypeResolveResult;
                    if (resolvedClass != null)
                    {
                        ClassNode callerNode = new ClassNode(resolvedClass.Type.FullName, resolvedClass);
                        callerNode = t.AddOrGetClassNode(resolvedClass.Type.Namespace, callerNode); //override if already in tree with that node

                        //3) edge (dependency) between caller and target
                        callerNode.AddDependency(targetNode);
                    }
                }
            }
            return(base.VisitIsExpression(isExpression, astResolver));
        }
            public override void VisitIsExpression(IsExpression isExpression)
            {
                base.VisitIsExpression(isExpression);

                var type         = ctx.Resolve(isExpression.Expression).Type;
                var providedType = ctx.ResolveType(isExpression.Type);

                if (type.Kind == TypeKind.Unknown || providedType.Kind == TypeKind.Unknown)
                {
                    return;
                }
//				var foundConversion = conversions.ImplicitConversion(type, providedType);
                if (!IsValidReferenceOrBoxingConversion(type, providedType))
                {
                    return;
                }

                var action = new CodeAction(
                    ctx.TranslateString("Compare with 'null'"),
                    script => script.Replace(isExpression, new BinaryOperatorExpression(
                                                 isExpression.Expression.Clone(), BinaryOperatorType.InEquality, new PrimitiveExpression(null))),
                    isExpression
                    );

                AddIssue(new CodeIssue(isExpression, ctx.TranslateString("Given expression is always of the provided type. Consider comparing with 'null' instead"), new [] { action }));
            }
        /// <summary>
        /// http://dlang.org/expression.html#IsExpression
        /// </summary>
        public ISemantic E(IsExpression isExpression)
        {
            if (!eval)
            {
                return(new PrimitiveType(DTokens.Bool));
            }

            bool retTrue = false;

            if (isExpression.TestedType != null)
            {
                var typeToCheck = DResolver.StripMemberSymbols(TypeDeclarationResolver.ResolveSingle(isExpression.TestedType, ctxt));

                if (typeToCheck != null)
                {
                    // case 1, 4
                    if (isExpression.TypeSpecialization == null && isExpression.TypeSpecializationToken == 0)
                    {
                        retTrue = true;
                    }

                    // The probably most frequented usage of this expression
                    else if (isExpression.TypeAliasIdentifierHash == 0)
                    {
                        retTrue = evalIsExpression_NoAlias(isExpression, typeToCheck);
                    }
                    else
                    {
                        retTrue = evalIsExpression_WithAliases(isExpression, typeToCheck);
                    }
                }
            }

            return(new PrimitiveValue(DTokens.Bool, retTrue?1:0, isExpression));
        }
			public override void VisitIsExpression (IsExpression isExpression)
			{
				base.VisitIsExpression (isExpression);

//				var conversions = CSharpConversions.Get(ctx.Compilation);
				var exprType = ctx.Resolve (isExpression.Expression).Type;
				var providedType = ctx.ResolveType (isExpression.Type);

				if (exprType.Kind == TypeKind.Unknown || providedType.Kind == TypeKind.Unknown)
					return;
				if (IsValidReferenceOrBoxingConversion(exprType, providedType))
					return;
				
				var exprTP = exprType as ITypeParameter;
				var providedTP = providedType as ITypeParameter;
				if (exprTP != null) {
					if (IsValidReferenceOrBoxingConversion(exprTP.EffectiveBaseClass, providedType)
					    && exprTP.EffectiveInterfaceSet.All(i => IsValidReferenceOrBoxingConversion(i, providedType)))
						return;
				}
				if (providedTP != null) {
					if (IsValidReferenceOrBoxingConversion(exprType, providedTP.EffectiveBaseClass))
						return;
				}
				
				AddIssue (isExpression, ctx.TranslateString ("Given expression is never of the provided type"));
			}
Beispiel #8
0
 /// <inheritdoc />
 public IFilterableQuery <T> And
 (
     Expression <Func <T, object> > property,
     IsExpression expression
 )
 {
     return(Where(property, expression));
 }
Beispiel #9
0
 /// <inheritdoc />
 public IFilterableQuery <T> And
 (
     string property,
     IsExpression expression
 )
 {
     return(Where(property, expression));
 }
        public static void SerializeIsExpression()
        {
            var v = new NumberLiteral(2);
            var a = new IsExpression(v, v);
            var b = SerializationUtil.Reserialize(a);

            Assert.AreEqual(a, b);
        }
 /// <inheritdoc />
 public virtual TQuery And
 (
     string property,
     IsExpression expression
 )
 {
     return(Where(property, expression));
 }
 /// <inheritdoc />
 public virtual TQuery And
 (
     Expression <Func <TSource, object> > property,
     IsExpression expression
 )
 {
     return(Where(property, expression));
 }
 /// <inheritdoc />
 public virtual TQuery Where
 (
     Expression <Func <TSource, object> > property,
     IsExpression expression
 )
 {
     return(Where(ExpressionHelper.GetPropertyName(property), expression));
 }
Beispiel #14
0
        public UnifiedElement VisitIsExpression(IsExpression expr, object data)
        {
            var op = UnifiedBinaryOperator.Create(
                "is", UnifiedBinaryOperatorKind.InstanceOf);
            var value = expr.Expression.TryAcceptForExpression(this);
            var type  = LookupType(expr.Type);

            return(UnifiedBinaryExpression.Create(value, op, type));
        }
 public override object Visit(IsExpression node, object obj)
 {
     if (node.Location == ((AstNode)obj).Location || found)
     {
         found = true;
         return(this.table);
     }
     return(base.Visit(node, obj));
 }
        private bool evalIsExpression_WithAliases(IsExpression isExpression, AbstractType typeToCheck)
        {
            /*
             * Note: It's needed to let the abstract ast scanner also scan through IsExpressions etc.
             * in order to find aliases and/or specified template parameters!
             */

            var expectedTemplateParams = new TemplateParameter[isExpression.TemplateParameterList.Length + 1];

            expectedTemplateParams [0] = isExpression.ArtificialFirstSpecParam;
            if (expectedTemplateParams.Length > 1)
            {
                isExpression.TemplateParameterList.CopyTo(expectedTemplateParams, 1);
            }

            var tpl_params = new DeducedTypeDictionary(expectedTemplateParams);


            var  tpd     = new TemplateParameterDeduction(tpl_params, ctxt);
            bool retTrue = false;

            if (isExpression.EqualityTest)             // 6.
            {
                // a)
                if (isExpression.TypeSpecialization != null)
                {
                    tpd.EnforceTypeEqualityWhenDeducing = true;
                    retTrue = tpd.Handle(isExpression.ArtificialFirstSpecParam, typeToCheck);
                    tpd.EnforceTypeEqualityWhenDeducing = false;
                }
                else                 // b)
                {
                    var r = evalIsExpression_EvalSpecToken(isExpression, typeToCheck, true);
                    retTrue = r.Item1;
                    tpl_params[isExpression.TypeAliasIdentifierHash] = new TemplateParameterSymbol(null, r.Item2);
                }
            }
            else             // 5.
            {
                retTrue = tpd.Handle(isExpression.ArtificialFirstSpecParam, typeToCheck);
            }

            if (retTrue && isExpression.TemplateParameterList != null)
            {
                foreach (var p in isExpression.TemplateParameterList)
                {
                    if (!tpd.Handle(p, tpl_params[p.NameHash] != null ? tpl_params[p.NameHash].Base : null))
                    {
                        return(false);
                    }
                }
            }

            //TODO: Put all tpl_params results into the resolver context or make a new scope or something!

            return(retTrue);
        }
Beispiel #17
0
        public void NullableIsExpression()
        {
            IsExpression ce   = ParseUtilCSharp.ParseExpression <IsExpression>("o is int?");
            ComposedType type = (ComposedType)ce.Type;

            Assert.IsTrue(type.HasNullableSpecifier);
            Assert.AreEqual("int", ((PrimitiveType)type.BaseType).Keyword);
            Assert.IsTrue(ce.Expression is IdentifierExpression);
        }
            public override void VisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression)
            {
                base.VisitBinaryOperatorExpression(binaryOperatorExpression);

                var m = pattern.Match(binaryOperatorExpression);

                if (!m.Success)
                {
                    return;
                }

                Expression identifier = null;
                AstType    type       = null;

                if (binaryOperatorExpression.Left is TypeOfExpression && binaryOperatorExpression.Right is InvocationExpression)
                {
                    type = (binaryOperatorExpression.Left as TypeOfExpression).Type;
                    var right = binaryOperatorExpression.Right as InvocationExpression;
                    identifier = (right.Target as MemberReferenceExpression).Target;
                }
                else if (binaryOperatorExpression.Right is TypeOfExpression && binaryOperatorExpression.Left is InvocationExpression)
                {
                    type = (binaryOperatorExpression.Right as TypeOfExpression).Type;
                    var left = binaryOperatorExpression.Left as InvocationExpression;
                    identifier = (left.Target as MemberReferenceExpression).Target;
                }
                else
                {
                    return;
                }

                if (identifier == null || type == null)
                {
                    return;
                }

                var typeResolved = ctx.Resolve(type) as TypeResolveResult;

                if (typeResolved.Type.Kind == TypeKind.Class)
                {
                    if (!typeResolved.Type.GetDefinition().IsSealed)
                    {
                        return;
                    }
                }

                AddIssue(
                    binaryOperatorExpression,
                    ctx.TranslateString("Operator 'is' can be used"),
                    ctx.TranslateString("Replace with 'is' operator"),
                    script => {
                    var isExpr = new IsExpression(identifier.Clone(), type.Clone());
                    script.Replace(binaryOperatorExpression, isExpr);
                }
                    );
            }
Beispiel #19
0
        /// <inheritdoc />
        public IFilterableQuery <TSource> Where
        (
            string property,
            IsExpression expression
        )
        {
            _query.Where(property, expression);

            return(this);
        }
Beispiel #20
0
 public override void Visit(IsExpression x)
 {
     if (x.TypeAliasIdentifierHash == searchHash &&
         symbol is TemplateParameter.Node &&
         (symbol as TemplateParameter.Node).TemplateParameter == x.ArtificialFirstSpecParam)
     {
         l.Add(x.ArtificialFirstSpecParam);
     }
     base.Visit(x);
 }
        /// <inheritdoc />
        public virtual TQuery Where
        (
            string property,
            IsExpression expression
        )
        {
            ICriterion criterion = expression.Compile(property);

            return(Where(criterion));
        }
Beispiel #22
0
        /// <inheritdoc />
        public IFilterableQuery <TSource> Where
        (
            Expression <Func <TSource, object> > property,
            IsExpression expression
        )
        {
            _query.Where(property, expression);

            return(this);
        }
Beispiel #23
0
        public override Object Visit(IsExpression node, Object obj)
        {
            IsExpression clonedIsExpression = new IsExpression((Expression)node.Expression.Accept(this, obj), node.TypeId, node.Location);

            if (node.TypeExpr != null)
            {
                clonedIsExpression.TypeExpr = node.TypeExpr.CloneType(typeVariableMappings, this.typeExpresionVariableMapping);
            }
            return(clonedIsExpression);
        }
Beispiel #24
0
        public override Object Visit(IsExpression node, Object obj)
        {
            Object aux = null;

            node.Expression.LeftExpression = node.LeftExpression;
            if ((aux = node.Expression.Accept(this, false)) is SingleIdentifierExpression)
            {
                node.Expression = (SingleIdentifierExpression)aux;
            }
            return(null);
        }
Beispiel #25
0
        public override Object Visit(IsExpression node, Object obj)
        {
            int indent = Convert.ToInt32(obj);

            this.printIndentation(indent);
            this.output.WriteLine("IsExpression Type: {0} [{1}:{2}]", printType(node.ExpressionType), node.Location.Line, node.Location.Column);
            node.Expression.Accept(this, indent + 1);
            this.printIndentation(indent + 1);
            this.output.WriteLine(printType(node.TypeExpr));
            return(null);
        }
			public override void VisitIsExpression (IsExpression isExpression)
			{
				base.VisitIsExpression (isExpression);

				var exprType = ctx.Resolve (isExpression.Expression).Type;
				var providedType = ctx.ResolveType (isExpression.Type);

				if (TypeCompatibilityHelper.CheckTypeCompatibility(exprType, providedType) == 
					TypeCompatibilityHelper.TypeCompatiblity.NeverOfProvidedType)
					AddIssue (isExpression, ctx.TranslateString ("Given expression is never of the provided type"));
			}
Beispiel #27
0
        /// <inheritdoc />
        public IFilterableQuery <T> Where
        (
            Expression <Func <T, object> > property,
            IsExpression expression
        )
        {
            Expression <Func <TSource, object> > temp = _rebaser.RebaseTo <TSource, object>(property);

            _query.Where(temp, expression);

            return(this);
        }
Beispiel #28
0
        public void NullableIsExpressionInBinaryOperatorExpression()
        {
            BinaryOperatorExpression boe;

            boe = ParseUtilCSharp.ParseExpression <BinaryOperatorExpression>("o is int? == true");
            IsExpression ce   = (IsExpression)boe.Left;
            ComposedType type = (ComposedType)ce.Type;

            Assert.IsTrue(type.HasNullableSpecifier);
            Assert.AreEqual("int", ((PrimitiveType)type.BaseType).Keyword);
            Assert.IsTrue(ce.Expression is IdentifierExpression);
        }
Beispiel #29
0
            public override void VisitIsExpression(IsExpression isExpression)
            {
                base.VisitIsExpression(isExpression);

                var exprType     = ctx.Resolve(isExpression.Expression).Type;
                var providedType = ctx.ResolveType(isExpression.Type);

                if (TypeCompatibilityHelper.CheckTypeCompatibility(exprType, providedType) ==
                    TypeCompatibilityHelper.TypeCompatiblity.NeverOfProvidedType)
                {
                    AddIssue(isExpression, ctx.TranslateString("Given expression is never of the provided type"));
                }
            }
        private bool evalIsExpression_NoAlias(IsExpression isExpression, AbstractType typeToCheck)
        {
            if (isExpression.TypeSpecialization != null)
            {
                var spec = DResolver.StripAliasSymbols(TypeDeclarationResolver.Resolve(isExpression.TypeSpecialization, ctxt));

                return(spec != null && spec.Length != 0 && (isExpression.EqualityTest ?
                                                            ResultComparer.IsEqual(typeToCheck, spec[0]) :
                                                            ResultComparer.IsImplicitlyConvertible(typeToCheck, spec[0], ctxt)));
            }

            return(isExpression.EqualityTest && evalIsExpression_EvalSpecToken(isExpression, typeToCheck, false).Item1);
        }
 public override void VisitIsExpression(IsExpression isExpression)
 {
     if (InsertParenthesesForReadability)
     {
         // few people know the precedence of 'is', so always put parentheses in nice-looking mode.
         ParenthesizeIfRequired(isExpression.Expression, NullableRewrap);
     }
     else
     {
         ParenthesizeIfRequired(isExpression.Expression, RelationalAndTypeTesting);
     }
     base.VisitIsExpression(isExpression);
 }
 public override object VisitIsExpression(IsExpression isExpression, object data)
 {
     if (InsertParenthesesForReadability)
     {
         // few people know the precedence of 'is', so always put parentheses in nice-looking mode.
         ParenthesizeIfRequired(isExpression.Expression, Primary);
     }
     else
     {
         ParenthesizeIfRequired(isExpression.Expression, RelationalAndTypeTesting);
     }
     return(base.VisitIsExpression(isExpression, data));
 }
		private bool evalIsExpression_WithAliases(IsExpression isExpression, AbstractType typeToCheck)
		{
			/*
			 * Note: It's needed to let the abstract ast scanner also scan through IsExpressions etc.
			 * in order to find aliases and/or specified template parameters!
			 */

			var expectedTemplateParams = new TemplateParameter[isExpression.TemplateParameterList == null  ? 1 : (isExpression.TemplateParameterList.Length + 1)];
			expectedTemplateParams [0] = isExpression.ArtificialFirstSpecParam;
			if(expectedTemplateParams.Length > 1)
				isExpression.TemplateParameterList.CopyTo (expectedTemplateParams, 1);

			var tpl_params = new DeducedTypeDictionary(expectedTemplateParams);


			var tpd = new TemplateParameterDeduction(tpl_params, ctxt);
			bool retTrue = false;

			if (isExpression.EqualityTest) // 6.
			{
				// a)
				if (isExpression.TypeSpecialization != null)
				{
					tpd.EnforceTypeEqualityWhenDeducing = true;
					retTrue = tpd.Handle(isExpression.ArtificialFirstSpecParam, typeToCheck);
					tpd.EnforceTypeEqualityWhenDeducing = false;
				}
				else // b)
				{
					var r = evalIsExpression_EvalSpecToken(isExpression, typeToCheck, true);
					retTrue = r.Item1;
					tpl_params[isExpression.ArtificialFirstSpecParam] = new TemplateParameterSymbol(isExpression.ArtificialFirstSpecParam, r.Item2);
				}
			}
			else // 5.
				retTrue = tpd.Handle(isExpression.ArtificialFirstSpecParam, typeToCheck);

			if (retTrue && isExpression.TemplateParameterList != null)
				foreach (var p in isExpression.TemplateParameterList)
					if (!tpd.Handle(p, tpl_params[p] != null ? tpl_params[p].Base : null))
						return false;

			if (retTrue)
			{
				foreach (var kv in tpl_params)
					ctxt.CurrentContext.DeducedTemplateParameters[kv.Key] = kv.Value;
			}

			return retTrue;
		}
Beispiel #34
0
        /// <inheritdoc />
        public IFilterableQuery <T> Where
        (
            string property,
            IsExpression expression
        )
        {
            if (!property.Contains("."))
            {
                property = _alias + "." + property;
            }

            _query.Where(property, expression);

            return(this);
        }
			public override void VisitIsExpression (IsExpression isExpression)
			{
				base.VisitIsExpression (isExpression);

				var type = ctx.Resolve (isExpression.Expression).Type;
				var providedType = ctx.ResolveType (isExpression.Type);

				if (type.GetAllBaseTypes ().All (t => !t.Equals (providedType)))
					return;

				var action = new CodeAction (ctx.TranslateString ("Compare with 'null'"), 
					scrpit => scrpit.Replace (isExpression, new BinaryOperatorExpression (
						isExpression.Expression.Clone (), BinaryOperatorType.InEquality, new PrimitiveExpression (null))));
				AddIssue (isExpression, ctx.TranslateString ("Given expression is always of the provided type. " +
					"Consider comparing with 'null' instead"), new [] { action });
			}
		private bool evalIsExpression_WithAliases(IsExpression isExpression, AbstractType typeToCheck)
		{
			/*
			 * Note: It's needed to let the abstract ast scanner also scan through IsExpressions etc.
			 * in order to find aliases and/or specified template parameters!
			 */

			var expectedTemplateParams = new TemplateParameter[isExpression.TemplateParameterList.Length + 1];
			expectedTemplateParams [0] = isExpression.ArtificialFirstSpecParam;
			if(expectedTemplateParams.Length > 1)
				isExpression.TemplateParameterList.CopyTo (expectedTemplateParams, 1);

			var tpl_params = new DeducedTypeDictionary(expectedTemplateParams);


			var tpd = new TemplateParameterDeduction(tpl_params, ctxt);
			bool retTrue = false;

			if (isExpression.EqualityTest) // 6.
			{
				// a)
				if (isExpression.TypeSpecialization != null)
				{
					tpd.EnforceTypeEqualityWhenDeducing = true;
					retTrue = tpd.Handle(isExpression.ArtificialFirstSpecParam, typeToCheck);
					tpd.EnforceTypeEqualityWhenDeducing = false;
				}
				else // b)
				{
					var r = evalIsExpression_EvalSpecToken(isExpression, typeToCheck, true);
					retTrue = r.Item1;
					tpl_params[isExpression.TypeAliasIdentifierHash] = new TemplateParameterSymbol(null, r.Item2);
				}
			}
			else // 5.
				retTrue = tpd.Handle(isExpression.ArtificialFirstSpecParam, typeToCheck);

			if (retTrue && isExpression.TemplateParameterList != null)
				foreach (var p in isExpression.TemplateParameterList)
					if (!tpd.Handle(p, tpl_params[p.NameHash] != null ? tpl_params[p.NameHash].Base : null))
						return false;

			//TODO: Put all tpl_params results into the resolver context or make a new scope or something! 

			return retTrue;
		}
			public override void VisitIsExpression (IsExpression isExpression)
			{
				base.VisitIsExpression (isExpression);

				var type = ctx.Resolve (isExpression.Expression).Type;
				var providedType = ctx.ResolveType (isExpression.Type);

//				var foundConversion = conversions.ImplicitConversion(type, providedType);
				if (!IsValidReferenceOrBoxingConversion(type, providedType))
					return;

				var action = new CodeAction (ctx.TranslateString ("Compare with 'null'"), 
					scrpit => scrpit.Replace (isExpression, new BinaryOperatorExpression (
						isExpression.Expression.Clone (), BinaryOperatorType.InEquality, new PrimitiveExpression (null))));
				AddIssue (isExpression, ctx.TranslateString ("Given expression is always of the provided type. " +
					"Consider comparing with 'null' instead"), new [] { action });
			}
 public virtual void VisitIsExpression(IsExpression isExpression)
 {
     if (this.ThrowException)
     {
         throw (Exception)this.CreateException(isExpression);
     }
 }
		public override void VisitIsExpression(IsExpression isExpression)
		{
			if (InsertParenthesesForReadability) {
				// few people know the precedence of 'is', so always put parentheses in nice-looking mode.
				ParenthesizeIfRequired(isExpression.Expression, Primary);
			} else {
				ParenthesizeIfRequired(isExpression.Expression, RelationalAndTypeTesting);
			}
			base.VisitIsExpression(isExpression);
		}
		List<MethodDeclaration> CreateEqualsOverrides(IType currentClass)
		{
			List<MethodDeclaration> methods = new List<MethodDeclaration>();
			
			AstType boolReference = ConvertType(KnownTypeCode.Boolean);
			AstType objectReference = ConvertType(KnownTypeCode.Object);
			
			MethodDeclaration method = new MethodDeclaration {
				Name = "Equals",
				Modifiers = Modifiers.Public | Modifiers.Override,
				ReturnType = boolReference
			};
			method.Parameters.Add(new ParameterDeclaration(objectReference, "obj"));
			method.Body = new BlockStatement();
			
			AstType currentType = ConvertType(currentClass);
			Expression expr = null;
			
			if (currentClass.Kind == TypeKind.Struct) {
				// return obj is CurrentType && Equals((CurrentType)obj);
				expr = new IsExpression() {
					Expression = new IdentifierExpression("obj"),
					Type = currentType.Clone()
				};
				expr = new ParenthesizedExpression(expr);
				expr = new BinaryOperatorExpression(
					expr, BinaryOperatorType.ConditionalAnd,
					new InvocationExpression(
						new IdentifierExpression("Equals"),
						new List<Expression> {
							new CastExpression(currentType.Clone(), new IdentifierExpression("obj"))
						}));
				method.Body.Add(new ReturnStatement(expr));
				
				methods.Add(method);
				
				// IEquatable implementation:
				method = new MethodDeclaration {
					Name = "Equals",
					Modifiers = Modifiers.Public,
					ReturnType = boolReference.Clone()
				};
				method.Parameters.Add(new ParameterDeclaration(currentType, "other"));
				method.Body = new BlockStatement();
			} else {
				method.Body.Add(new VariableDeclarationStatement(
					currentType.Clone(),
					"other",
					new IdentifierExpression("obj").CastAs(currentType.Clone())));
				method.Body.Add(new IfElseStatement(
					new BinaryOperatorExpression(new IdentifierExpression("other"), BinaryOperatorType.Equality, new PrimitiveExpression(null, "null")),
					new ReturnStatement(new PrimitiveExpression(false, "false"))));
			}
			
			expr = null;
			foreach (IField field in currentClass.GetFields()) {
				if (field.IsStatic) continue;
				
				if (expr == null) {
					expr = TestEquality("other", field);
				} else {
					expr = new BinaryOperatorExpression(expr, BinaryOperatorType.ConditionalAnd,
					                                    TestEquality("other", field));
				}
			}
			
			foreach (IProperty property in currentClass.GetProperties()) {
				if (property.IsStatic || !property.IsAutoImplemented()) continue;
				if (expr == null) {
					expr = TestEquality("other", property);
				} else {
					expr = new BinaryOperatorExpression(expr, BinaryOperatorType.ConditionalAnd,
					                                    TestEquality("other", property));
				}
			}
			
			method.Body.Add(new ReturnStatement(expr ?? new PrimitiveExpression(true, "true")));
			
			methods.Add(method);
			
			return methods;
		}
		public void Visit(IsExpression x)
		{
			
		}
        private bool evalIsExpression_NoAlias(IsExpression isExpression, AbstractType typeToCheck)
        {
            if (isExpression.TypeSpecialization != null)
            {
                var spec = DResolver.StripAliasSymbols(TypeDeclarationResolver.Resolve(isExpression.TypeSpecialization, ctxt));

                return spec != null && spec.Length != 0 && (isExpression.EqualityTest ?
                    ResultComparer.IsEqual(typeToCheck, spec[0]) :
                    ResultComparer.IsImplicitlyConvertible(typeToCheck, spec[0], ctxt));
            }

            return isExpression.EqualityTest && evalIsExpression_EvalSpecToken(isExpression, typeToCheck, false).Item1;
        }
Beispiel #43
0
        IExpression PrimaryExpression(IBlockNode Scope=null)
        {
            bool isModuleScoped = false;
            // For minimizing possible overhead, skip 'useless' tokens like an initial dot <<< TODO
            if (isModuleScoped= laKind == Dot)
                Step();

            if (laKind == __FILE__ || laKind == __LINE__)
            {
                Step();

                object id = null;

                if (t.Kind == __FILE__ && doc != null)
                    id = doc.FileName;
                else if(t.Kind==__LINE__)
                    id = t.line;

                return new IdentifierExpression(id)
                {
                    Location=t.Location,
                    EndLocation=t.EndLocation
                };
            }

            // Dollar (== Array length expression)
            if (laKind == Dollar)
            {
                Step();
                return new TokenExpression(laKind)
                {
                    Location = t.Location,
                    EndLocation = t.EndLocation
                };
            }

            // TemplateInstance
            if (laKind == (Identifier) && Lexer.CurrentPeekToken.Kind == (Not)
                && (Peek().Kind != Is && Lexer.CurrentPeekToken.Kind != In)
                /* Very important: The 'template' could be a '!is'/'!in' expression - With two tokens each! */)
                return TemplateInstance();

            // Identifier
            if (laKind == (Identifier))
            {
                Step();
                return new IdentifierExpression(t.Value)
                {
                    Location = t.Location,
                    EndLocation = t.EndLocation
                };
            }

            // SpecialTokens (this,super,null,true,false,$) // $ has been handled before
            if (laKind == (This) || laKind == (Super) || laKind == (Null) || laKind == (True) || laKind == (False))
            {
                Step();
                return new TokenExpression(t.Kind)
                {
                    Location = t.Location,
                    EndLocation = t.EndLocation
                };
            }

            #region Literal
            if (laKind == Literal)
            {
                Step();
                var startLoc = t.Location;

                // Concatenate multiple string literals here
                if (t.LiteralFormat == LiteralFormat.StringLiteral || t.LiteralFormat == LiteralFormat.VerbatimStringLiteral)
                {
                    var a = t.LiteralValue as string;
                    while (la.LiteralFormat == LiteralFormat.StringLiteral || la.LiteralFormat == LiteralFormat.VerbatimStringLiteral)
                    {
                        Step();
                        a += t.LiteralValue as string;
                    }
                    return new IdentifierExpression(a, t.LiteralFormat) { Location = startLoc, EndLocation = t.EndLocation };
                }
                //else if (t.LiteralFormat == LiteralFormat.CharLiteral)return new IdentifierExpression(t.LiteralValue) { LiteralFormat=t.LiteralFormat,Location = startLoc, EndLocation = t.EndLocation };
                return new IdentifierExpression(t.LiteralValue, t.LiteralFormat) { Location = startLoc, EndLocation = t.EndLocation };
            }
            #endregion

            #region ArrayLiteral | AssocArrayLiteral
            if (laKind == (OpenSquareBracket))
            {
                Step();
                var startLoc = t.Location;

                // Empty array literal
                if (laKind == CloseSquareBracket)
                {
                    Step();
                    return new ArrayLiteralExpression() {Location=startLoc, EndLocation = t.EndLocation };
                }

                var firstExpression = AssignExpression();

                // Associtative array
                if (laKind == Colon)
                {
                    Step();

                    var ae = new AssocArrayExpression() { Location=startLoc};
                    LastParsedObject = ae;

                    var firstValueExpression = AssignExpression();

                    ae.KeyValuePairs.Add(firstExpression, firstValueExpression);

                    while (laKind == Comma)
                    {
                        Step();
                        var keyExpr = AssignExpression();
                        Expect(Colon);
                        var valueExpr = AssignExpression();

                        ae.KeyValuePairs.Add(keyExpr, valueExpr);
                    }

                    Expect(CloseSquareBracket);
                    ae.EndLocation = t.EndLocation;
                    return ae;
                }
                else // Normal array literal
                {
                    var ae = new ArrayLiteralExpression() { Location=startLoc};
                    LastParsedObject = ae;
                    var expressions = new List<IExpression>();
                    expressions.Add(firstExpression);

                    while (laKind == Comma)
                    {
                        Step();
                        if (laKind == CloseSquareBracket) // And again, empty expressions are allowed
                            break;
                        expressions.Add(AssignExpression());
                    }

                    ae.Expressions = expressions;

                    Expect(CloseSquareBracket);
                    ae.EndLocation = t.EndLocation;
                    return ae;
                }
            }
            #endregion

            #region FunctionLiteral
            if (laKind == Delegate || laKind == Function || laKind == OpenCurlyBrace || (laKind == OpenParenthesis && IsFunctionLiteral()))
            {
                var fl = new FunctionLiteral() { Location=la.Location};
                LastParsedObject = fl;
                fl.AnonymousMethod.StartLocation = la.Location;

                if (laKind == Delegate || laKind == Function)
                {
                    Step();
                    fl.LiteralToken = t.Kind;
                }

                // file.d:1248
                /*
                    listdir (".", delegate bool (DirEntry * de)
                    {
                        auto s = std.string.format("%s : c %s, w %s, a %s", de.name,
                                toUTCString (de.creationTime),
                                toUTCString (de.lastWriteTime),
                                toUTCString (de.lastAccessTime));
                        return true;
                    }
                    );
                */
                if (laKind != OpenCurlyBrace) // foo( 1, {bar();} ); -> is a legal delegate
                {
                    if (!MemberFunctionAttribute[laKind] && Lexer.CurrentPeekToken.Kind == OpenParenthesis)
                        fl.AnonymousMethod.Type = BasicType();
                    else if (laKind != OpenParenthesis && laKind != OpenCurlyBrace)
                        fl.AnonymousMethod.Type = Type();

                    if (laKind == OpenParenthesis)
                        fl.AnonymousMethod.Parameters = Parameters(fl.AnonymousMethod);
                }

                FunctionBody(fl.AnonymousMethod);

                fl.EndLocation = t.EndLocation;

                if (Scope != null)
                    Scope.Add(fl.AnonymousMethod);

                return fl;
            }
            #endregion

            #region AssertExpression
            if (laKind == (Assert))
            {
                Step();
                var startLoc = t.Location;
                Expect(OpenParenthesis);
                var ce = new AssertExpression() { Location=startLoc};
                LastParsedObject = ce;

                var exprs = new List<IExpression>();
                exprs.Add(AssignExpression());

                if (laKind == (Comma))
                {
                    Step();
                    exprs.Add(AssignExpression());
                }
                ce.AssignExpressions = exprs.ToArray();
                Expect(CloseParenthesis);
                ce.EndLocation = t.EndLocation;
                return ce;
            }
            #endregion

            #region MixinExpression | ImportExpression
            if (laKind == Mixin)
            {
                Step();
                var e = new MixinExpression() { Location=t.Location};
                LastParsedObject = e;
                Expect(OpenParenthesis);

                e.AssignExpression = AssignExpression();

                Expect(CloseParenthesis);
                e.EndLocation = t.EndLocation;
                return e;
            }

            if (laKind == Import)
            {
                Step();
                var e = new ImportExpression() { Location=t.Location};
                LastParsedObject = e;
                Expect(OpenParenthesis);

                e.AssignExpression = AssignExpression();

                Expect(CloseParenthesis);
                e.EndLocation = t.EndLocation;
                return e;
            }
            #endregion

            if (laKind == (Typeof))
            {
                var startLoc = la.Location;
                return new TypeDeclarationExpression(TypeOf()) {Location=startLoc,EndLocation=t.EndLocation};
            }

            // TypeidExpression
            if (laKind == (Typeid))
            {
                Step();
                var ce = new TypeidExpression() { Location=t.Location};
                LastParsedObject = ce;
                Expect(OpenParenthesis);

                AllowWeakTypeParsing = true;
                ce.Type = Type();
                AllowWeakTypeParsing = false;

                if (ce.Type==null)
                    ce.Expression = AssignExpression();

                Expect(CloseParenthesis);
                ce.EndLocation = t.EndLocation;
                return ce;
            }

            #region IsExpression
            if (laKind == Is)
            {
                Step();
                var ce = new IsExpression() { Location=t.Location};
                LastParsedObject = ce;
                Expect(OpenParenthesis);

                var LookAheadBackup = la;

                AllowWeakTypeParsing = true;
                ce.TestedType = Type();
                AllowWeakTypeParsing = false;

                if (ce.TestedType!=null && laKind == Identifier && (Lexer.CurrentPeekToken.Kind == CloseParenthesis || Lexer.CurrentPeekToken.Kind == Equal
                    || Lexer.CurrentPeekToken.Kind == Colon))
                {
                    Step();
                    ce.TypeAliasIdentifier = strVal;
                }
                else
                // D Language specs mistake: In an IsExpression there also can be expressions!
                if(ce.TestedType==null || !(laKind==CloseParenthesis || laKind==Equal||laKind==Colon))
                {
                    // Reset lookahead token to prior position
                    la = LookAheadBackup;
                    // Reset wrongly parsed type declaration
                    ce.TestedType = null;
                    ce.TestedExpression = ConditionalExpression();
                }

                if(ce.TestedExpression==null && ce.TestedType==null)
                    SynErr(laKind,"In an IsExpression, either a type or an expression is required!");

                if (laKind == CloseParenthesis)
                {
                    Step();
                    ce.EndLocation = t.EndLocation;
                    return ce;
                }

                if (laKind == Colon || laKind == Equal)
                {
                    Step();
                    ce.EqualityTest = t.Kind == Equal;
                }
                else if (laKind == CloseParenthesis)
                {
                    Step();
                    ce.EndLocation = t.EndLocation;
                    return ce;
                }

                /*
                TypeSpecialization:
                    Type
                        struct
                        union
                        class
                        interface
                        enum
                        function
                        delegate
                        super
                    const
                    immutable
                    inout
                    shared
                        return
                */

                if (ClassLike[laKind] || laKind==Typedef || // typedef is possible although it's not yet documented in the syntax docs
                    laKind==Enum || laKind==Delegate || laKind==Function || laKind==Super || laKind==Return)
                {
                    Step();
                    ce.TypeSpecializationToken = t.Kind;
                }
                else
                    ce.TypeSpecialization = Type();

                if (laKind == Comma)
                {
                    Step();
                    ce.TemplateParameterList =
                        TemplateParameterList(false);
                }

                Expect(CloseParenthesis);
                ce.EndLocation = t.EndLocation;
                return ce;
            }
            #endregion

            // ( Expression )
            if (laKind == OpenParenthesis)
            {
                Step();
                var ret = new SurroundingParenthesesExpression() {Location=t.Location };
                LastParsedObject = ret;

                ret.Expression = Expression();

                Expect(CloseParenthesis);
                ret.EndLocation = t.EndLocation;
                return ret;
            }

            // TraitsExpression
            if (laKind == (__traits))
                return TraitsExpression();

            #region BasicType . Identifier
            if (laKind == (Const) || laKind == (Immutable) || laKind == (Shared) || laKind == (InOut) || BasicTypes[laKind])
            {
                Step();
                var startLoc = t.Location;
                IExpression left = null;
                if (!BasicTypes[t.Kind])
                {
                    int tk = t.Kind;
                    // Put an artificial parenthesis around the following type declaration
                    if (laKind != OpenParenthesis)
                    {
                        var mttd = new MemberFunctionAttributeDecl(tk);
                        LastParsedObject = mttd;
                        mttd.InnerType = Type();
                        left = new TypeDeclarationExpression(mttd) { Location = startLoc, EndLocation = t.EndLocation };
                    }
                    else
                    {
                        Expect(OpenParenthesis);
                        var mttd = new MemberFunctionAttributeDecl(tk);
                        LastParsedObject = mttd;
                        mttd.InnerType = Type();
                        Expect(CloseParenthesis);
                        left = new TypeDeclarationExpression(mttd) { Location = startLoc, EndLocation = t.EndLocation };
                    }
                }
                else
                    left = new TokenExpression(t.Kind) {Location=startLoc,EndLocation=t.EndLocation };

                if (laKind == (Dot) && Peek(1).Kind==Identifier)
                {
                    Step();
                    Step();

                    var meaex = new PostfixExpression_Access() { PostfixForeExpression=left,
                        TemplateOrIdentifier=new IdentifierDeclaration(t.Value),EndLocation=t.EndLocation };

                    return meaex;
                }
                return left;
            }
            #endregion

            // TODO? Expressions can of course be empty...
            //return null;

            SynErr(Identifier);
            Step();
            return new TokenExpression(t.Kind) { Location = t.Location, EndLocation = t.EndLocation };
        }
 public override void VisitIsExpression(IsExpression isExpression)
 {
     new CastBlock(this, isExpression).Emit();
 }
        /// <summary>
        /// Reads an is expression.
        /// </summary>
        /// <param name="leftHandSide">The expression on the left hand side of the operator.</param>
        /// <param name="previousPrecedence">The precedence of the expression just before this one.</param>
        /// <param name="unsafeCode">Indicates whether the code being parsed resides in an unsafe code block.</param>
        /// <returns>Returns the expression.</returns>
        private IsExpression GetIsExpression(
            Expression leftHandSide, ExpressionPrecedence previousPrecedence, bool unsafeCode)
        {
            Param.AssertNotNull(leftHandSide, "leftHandSide");
            Param.Ignore(previousPrecedence);
            Param.Ignore(unsafeCode);

            IsExpression expression = null;

            // Check the previous precedence to see if we are allowed to gather up the is expression.
            if (this.CheckPrecedence(previousPrecedence, ExpressionPrecedence.Relational))
            {
                // Make sure the left hand side has at least one token.
                Debug.Assert(leftHandSide.Tokens.First != null, "The left hand side should not be empty");

                // Get the is symbol.
                this.tokens.Add(this.GetToken(CsTokenType.Is, SymbolType.Is));

                // The next token must be the type.
                this.GetNextSymbol(SymbolType.Other);

                // Get the expression representing the type.
                LiteralExpression rightHandSide = this.GetTypeTokenExpression(unsafeCode, true, true);
                if (rightHandSide == null || rightHandSide.Tokens.First == null)
                {
                    throw this.CreateSyntaxException();
                }

                // Create the partial token list for the expression.
                CsTokenList partialTokens = new CsTokenList(this.tokens, leftHandSide.Tokens.First, this.tokens.Last);

                // Create and return the expression.
                expression = new IsExpression(partialTokens, leftHandSide, rightHandSide);
            }

            return expression;
        }
Beispiel #46
0
		public void VisitIsExpression(IsExpression isExpression)
		{
			StartNode(isExpression);
			isExpression.Expression.AcceptVisitor(this);
			Space();
			WriteKeyword(IsExpression.IsKeywordRole);
			isExpression.Type.AcceptVisitor(this);
			EndNode(isExpression);
		}
		public virtual void VisitIsExpression (IsExpression isExpression)
		{
			VisitChildren (isExpression);
		}
			public override void VisitIsExpression (IsExpression isExpression)
			{
				base.VisitIsExpression (isExpression);

				var exprType = ctx.Resolve (isExpression.Expression).Type;
				var providedType = ctx.ResolveType (isExpression.Type);

				var exprBaseTypes = exprType.GetAllBaseTypes ().ToArray ();

				// providedType is a base type of exprType
				if (exprBaseTypes.Any (t => t.Equals (providedType)))
					return;

				if ((exprType.IsReferenceType == true && providedType.IsReferenceType == false) ||
					(exprType.IsReferenceType == false && providedType.IsReferenceType == true)) {
					AddIssue (isExpression);
					return;
				}

				var typeParameter = exprType as ITypeParameter;
				var providedTypeParameter = providedType as ITypeParameter;

				if (typeParameter != null) {
					// check if providedType can be a derived type
					var providedBaseTypes = providedType.GetAllBaseTypes ().ToArray ();
					var providedTypeDef = providedType.GetDefinition ();
					// if providedType is sealed, check if it fullfills all the type parameter constraints,
					// otherwise, only check if it is derived from EffectiveBaseClass
					if (providedTypeParameter == null && (providedTypeDef == null || providedTypeDef.IsSealed)) {
						if (CheckTypeParameterConstraints (providedType, providedBaseTypes, typeParameter))
							return;
					} else if (providedBaseTypes.Any (t => t.Equals (typeParameter.EffectiveBaseClass))) {
						return;
					}

					// if providedType is also a type parameter, check if base classes are compatible
					if (providedTypeParameter != null &&
						exprBaseTypes.Any (t => t.Equals (providedTypeParameter.EffectiveBaseClass)))
						return;

					AddIssue (isExpression);
					return;
				}
				// check if exprType fullfills all the type parameter constraints
				if (providedTypeParameter != null &&
					CheckTypeParameterConstraints (exprType, exprBaseTypes, providedTypeParameter))
					return;

				switch (exprType.Kind) {
					case TypeKind.Class:
						var exprTypeDef = exprType.GetDefinition ();
						if (exprTypeDef == null)
							return;
						// exprType is sealed, but providedType is not a base type of it or it does not
						// fullfill all the type parameter constraints
						if (exprTypeDef.IsSealed)
							break;

						// check if providedType can be a derived type
						if (providedType.Kind == TypeKind.Interface ||
							providedType.GetAllBaseTypes ().Any (t => t.Equals (exprType)))
							return;

						if (providedTypeParameter != null &&
							exprBaseTypes.Any (t => t.Equals (providedTypeParameter.EffectiveBaseClass)))
							return;

						break;

					case TypeKind.Struct:
					case TypeKind.Delegate:
					case TypeKind.Enum:
					case TypeKind.Array:
					case TypeKind.Anonymous:
					case TypeKind.Null:
						break;

					default:
						return;
				}
				AddIssue (isExpression);
			}
			void AddIssue(IsExpression isExpression)
			{
				AddIssue (isExpression, ctx.TranslateString ("Given expression is never of the provided type"));
			}
Beispiel #50
0
        IExpression PrimaryExpression(IBlockNode Scope=null)
        {
            bool isModuleScoped = laKind == Dot;
            if (isModuleScoped)
            {
                Step();
                if (IsEOF)
                {
                    var dot = new TokenExpression(Dot) { Location = t.Location, EndLocation = t.EndLocation };
                    return new PostfixExpression_Access{ PostfixForeExpression = dot, AccessExpression = new TokenExpression(DTokens.Incomplete) };
                }
            }

            // TemplateInstance
            if (IsTemplateInstance)
            {
                var tix = TemplateInstance(Scope);
                if (tix != null)
                    tix.ModuleScopedIdentifier = isModuleScoped;
                return tix;
            }

            if (IsLambaExpression())
                return LambaExpression(Scope);

            CodeLocation startLoc;
            switch (laKind)
            {
                // ArrayLiteral | AssocArrayLiteral
                case OpenSquareBracket:
                    return ArrayLiteral(Scope);
                case New:
                    return NewExpression(Scope);
                case Typeof:
                    return new TypeDeclarationExpression(TypeOf());
                case __traits:
                    return TraitsExpression();
                // Dollar (== Array length expression)
                case Dollar:
                    Step();
                    return new TokenExpression(t.Kind)
                    {
                        Location = t.Location,
                        EndLocation = t.EndLocation
                    };
                case Identifier:
                    Step();
                    return new IdentifierExpression(t.Value)
                    {
                        Location = t.Location,
                        EndLocation = t.EndLocation,
                        ModuleScoped = isModuleScoped
                    };
                // SpecialTokens (this,super,null,true,false,$) // $ has been handled before
                case This:
                case Super:
                case Null:
                case True:
                case False:
                    Step();
                    return new TokenExpression(t.Kind)
                    {
                        Location = t.Location,
                        EndLocation = t.EndLocation
                    };
                case OpenParenthesis:
                    if (IsFunctionLiteral())
                        goto case Function;
                    // ( Expression )
                    Step();
                    var ret = new SurroundingParenthesesExpression() {Location=t.Location };

                    ret.Expression = Expression();

                    Expect(CloseParenthesis);
                    ret.EndLocation = t.EndLocation;
                    return ret;
                case Literal:
                    Step();
                    startLoc = t.Location;

                    // Concatenate multiple string literals here
                    if (t.LiteralFormat == LiteralFormat.StringLiteral || t.LiteralFormat == LiteralFormat.VerbatimStringLiteral)
                    {
                        var sb = new StringBuilder(t.RawCodeRepresentation ?? t.Value);
                        while (la.LiteralFormat == LiteralFormat.StringLiteral || la.LiteralFormat == LiteralFormat.VerbatimStringLiteral)
                        {
                            Step();
                            sb.Append(t.RawCodeRepresentation ?? t.Value);
                        }
                        return new IdentifierExpression(sb.ToString(), t.LiteralFormat, t.Subformat) { Location = startLoc, EndLocation = t.EndLocation };
                    }
                    //else if (t.LiteralFormat == LiteralFormat.CharLiteral)return new IdentifierExpression(t.LiteralValue) { LiteralFormat=t.LiteralFormat,Location = startLoc, EndLocation = t.EndLocation };
                    return new IdentifierExpression(t.LiteralValue, t.LiteralFormat, t.Subformat) { Location = startLoc, EndLocation = t.EndLocation };
                // FunctionLiteral
                case Delegate:
                case Function:
                case OpenCurlyBrace:
                    var fl = new FunctionLiteral() { Location=la.Location};
                    fl.AnonymousMethod.Location = la.Location;

                    if (laKind == Delegate || laKind == Function)
                    {
                        Step();
                        fl.LiteralToken = t.Kind;
                    }

                    // file.d:1248
                    /*
                        listdir (".", delegate bool (DirEntry * de)
                        {
                            auto s = std.string.format("%s : c %s, w %s, a %s", de.name,
                                    toUTCString (de.creationTime),
                                    toUTCString (de.lastWriteTime),
                                    toUTCString (de.lastAccessTime));
                            return true;
                        }
                        );
                    */
                    if (laKind != OpenCurlyBrace) // foo( 1, {bar();} ); -> is a legal delegate
                    {
                        if (!IsFunctionAttribute && Lexer.CurrentPeekToken.Kind == OpenParenthesis)
                            fl.AnonymousMethod.Type = BasicType();
                        else if (laKind != OpenParenthesis && laKind != OpenCurlyBrace)
                            fl.AnonymousMethod.Type = Type();

                        if (laKind == OpenParenthesis)
                            fl.AnonymousMethod.Parameters = Parameters(fl.AnonymousMethod);

                        FunctionAttributes(fl.AnonymousMethod);
                    }

                    if (!IsEOF)
                    {
                        FunctionBody(fl.AnonymousMethod);
                        fl.EndLocation = fl.AnonymousMethod.EndLocation;
                    }
                    else
                        fl.EndLocation = la.Location;

                    if (Scope != null)
                        Scope.Add(fl.AnonymousMethod);

                    return fl;
                // AssertExpression
                case Assert:
                    Step();
                    startLoc = t.Location;
                    Expect(OpenParenthesis);
                    var ce = new AssertExpression() { Location=startLoc};

                    var exprs = new List<IExpression>();
                    exprs.Add(AssignExpression());

                    if (laKind == (Comma))
                    {
                        Step();
                        exprs.Add(AssignExpression());
                    }
                    ce.AssignExpressions = exprs.ToArray();
                    Expect(CloseParenthesis);
                    ce.EndLocation = t.EndLocation;
                    return ce;
                // MixinExpression
                case Mixin:
                    Step();
                    var me = new MixinExpression() { Location=t.Location};
                    if (Expect(OpenParenthesis))
                    {
                        me.AssignExpression = AssignExpression();
                        Expect(CloseParenthesis);
                    }
                    me.EndLocation = t.EndLocation;
                    return me;
                // ImportExpression
                case Import:
                    Step();
                    var ie = new ImportExpression() { Location=t.Location};
                    Expect(OpenParenthesis);

                    ie.AssignExpression = AssignExpression();

                    Expect(CloseParenthesis);
                    ie.EndLocation = t.EndLocation;
                    return ie;
                // TypeidExpression
                case Typeid:
                    Step();
                    var tide = new TypeidExpression() { Location=t.Location};
                    Expect(OpenParenthesis);

                    if (IsAssignExpression())
                        tide.Expression = AssignExpression(Scope);
                    else
                    {
                        Lexer.PushLookAheadBackup();
                        AllowWeakTypeParsing = true;
                        tide.Type = Type();
                        AllowWeakTypeParsing = false;

                        if (tide.Type == null || laKind != CloseParenthesis)
                        {
                            Lexer.RestoreLookAheadBackup();
                            tide.Expression = AssignExpression();
                        }
                        else
                            Lexer.PopLookAheadBackup();
                    }

                    Expect (CloseParenthesis);

                    tide.EndLocation = t.EndLocation;
                    return tide;
                // IsExpression
                case Is:
                    Step();
                    var ise = new IsExpression() { Location = t.Location };
                    Expect(OpenParenthesis);

                    if ((ise.TestedType = Type()) == null)
                        SynErr(laKind, "In an IsExpression, either a type or an expression is required!");

                    if (ise.TestedType != null)
                    {
                        if (laKind == Identifier && (Lexer.CurrentPeekToken.Kind == CloseParenthesis || Lexer.CurrentPeekToken.Kind == Equal
                            || Lexer.CurrentPeekToken.Kind == Colon))
                        {
                            Step();
                            Strings.Add(strVal);
                            ise.TypeAliasIdentifierHash = strVal.GetHashCode();
                            ise.TypeAliasIdLocation = t.Location;
                        }
                        else if (IsEOF)
                            ise.TypeAliasIdentifierHash = DTokens.IncompleteIdHash;
                    }

                    if (laKind == Colon || laKind == Equal)
                    {
                        Step();
                        ise.EqualityTest = t.Kind == Equal;
                    }
                    else if (laKind == CloseParenthesis)
                    {
                        Step();
                        ise.EndLocation = t.EndLocation;
                        return ise;
                    }

                    /*
                    TypeSpecialization:
                        Type
                            struct
                            union
                            class
                            interface
                            enum
                            function
                            delegate
                            super
                        const
                        immutable
                        inout
                        shared
                            return
                    */

                    bool specialTest = false;
                    if (ise.EqualityTest)
                    {
                        switch (laKind)
                        {
                            case Typedef: // typedef is possible although it's not yet documented in the syntax docs
                            case Enum:
                            case Delegate:
                            case Function:
                            case Super:
                            case Return:
                                specialTest = true;
                                break;
                            case Const:
                            case Immutable:
                            case InOut:
                            case Shared:
                                specialTest = Peek(1).Kind == CloseParenthesis || Lexer.CurrentPeekToken.Kind == Comma;
                                break;
                            default:
                                specialTest = IsClassLike(laKind);
                                break;
                        }
                    }
                    if (specialTest)
                    {
                        Step();
                        ise.TypeSpecializationToken = t.Kind;
                    }
                    else
                        ise.TypeSpecialization = Type();

                    // TemplateParameterList
                    if (laKind == Comma)
                    {
                        var tempParam = new List<TemplateParameter>();
                        do
                        {
                            Step();
                            tempParam.Add(TemplateParameter(null));
                        }
                        while (laKind == Comma);
                        ise.TemplateParameterList = tempParam.ToArray();
                    }

                    Expect(CloseParenthesis);
                    ise.EndLocation = t.EndLocation;
                    return ise;
                default:
                    if (DTokens.IsMetaIdentifier(laKind))
                        goto case Dollar;
                    else if (IsBasicType())
                    {
                        // BasicType . Identifier
                        startLoc = la.Location;

                        var bt=BasicType();

                        if ((bt is TypeOfDeclaration || bt is MemberFunctionAttributeDecl) && laKind!=Dot)
                            return new TypeDeclarationExpression(bt);

                        // Things like incomplete 'float.' expressions shall be parseable, too
                        if (Expect(Dot) && (Expect(Identifier) || IsEOF))
                            return new PostfixExpression_Access()
                            {
                                PostfixForeExpression = new TypeDeclarationExpression(bt),
                                AccessExpression = IsEOF ? new TokenExpression(Incomplete) as IExpression : new IdentifierExpression(t.Value) { Location=t.Location, EndLocation=t.EndLocation },
                                EndLocation = t.EndLocation
                            };

                        return null;
                    }

                    SynErr(Identifier);
                    if(laKind != CloseCurlyBrace)
                        Step();

                    if (IsEOF)
                        return new TokenExpression (DTokens.Incomplete) { Location = t.Location, EndLocation = t.Location };

                    // Don't know why, in rare situations, t tends to be null..
                    if (t == null)
                        return null;
                    return new TokenExpression() { Location = t.Location, EndLocation = t.EndLocation };
            }
        }
Beispiel #51
0
        public void VisitIsExpression(IsExpression isExpression)
        {
            JsonObject expression = CreateJsonExpression(isExpression);

            AddKeyword(expression, IsExpression.IsKeywordRole);
            expression.AddJsonValue("type-info", GenTypeInfo(isExpression.Type));
            expression.AddJsonValue("expression", GenExpression(isExpression.Expression));

            Push(expression);
        }
 public override void Visit(IsExpression x)
 {
     // is(Type |
     if (x.TypeAliasIdentifierHash == DTokens.IncompleteIdHash &&
         x.TestedType != null &&
         !IsIncompleteDeclaration(x.TestedType)) {
         halt = true;
         explicitlyNoCompletion = true;
     }
     else
         base.Visit (x);
 }
Beispiel #53
0
        IExpression PrimaryExpression(IBlockNode Scope=null)
        {
            bool isModuleScoped = laKind == Dot;
            if (isModuleScoped)
            {
                Step();
                if (IsEOF)
                {
                    LastParsedObject = new TokenExpression(Dot) { Location = t.Location, EndLocation = t.EndLocation };
                    TrackerVariables.ExpectingIdentifier = true;
                }
            }

            // Dollar (== Array length expression)
            if (laKind == Dollar || DTokens.MetaIdentifiers[laKind])
            {
                Step();
                return new TokenExpression(t.Kind)
                {
                    Location = t.Location,
                    EndLocation = t.EndLocation
                };
            }

            // TemplateInstance
            if (IsTemplateInstance)
            {
                var tix = TemplateInstance(Scope);
                if (tix != null)
                    tix.ModuleScopedIdentifier = isModuleScoped;
                return tix;
            }

            if (IsLambaExpression())
                return LambaExpression(Scope);

            // Identifier
            if (laKind == Identifier)
            {
                Step();

                return new IdentifierExpression(t.Value)
                    {
                        Location = t.Location,
                        EndLocation = t.EndLocation,
                        ModuleScoped = isModuleScoped
                    };
            }

            // SpecialTokens (this,super,null,true,false,$) // $ has been handled before
            if (laKind == (This) || laKind == (Super) || laKind == (Null) || laKind == (True) || laKind == (False))
            {
                Step();
                return new TokenExpression(t.Kind)
                {
                    Location = t.Location,
                    EndLocation = t.EndLocation
                };
            }

            #region Literal
            if (laKind == Literal)
            {
                Step();
                var startLoc = t.Location;

                // Concatenate multiple string literals here
                if (t.LiteralFormat == LiteralFormat.StringLiteral || t.LiteralFormat == LiteralFormat.VerbatimStringLiteral)
                {
                    var sb = new StringBuilder(t.RawCodeRepresentation ?? t.Value);
                    while (la.LiteralFormat == LiteralFormat.StringLiteral || la.LiteralFormat == LiteralFormat.VerbatimStringLiteral)
                    {
                        Step();
                        sb.Append(t.RawCodeRepresentation ?? t.Value);
                    }
                    return new IdentifierExpression(sb.ToString(), t.LiteralFormat, t.Subformat) { Location = startLoc, EndLocation = t.EndLocation };
                }
                //else if (t.LiteralFormat == LiteralFormat.CharLiteral)return new IdentifierExpression(t.LiteralValue) { LiteralFormat=t.LiteralFormat,Location = startLoc, EndLocation = t.EndLocation };
                return new IdentifierExpression(t.LiteralValue, t.LiteralFormat, t.Subformat) { Location = startLoc, EndLocation = t.EndLocation };
            }
            #endregion

            #region ArrayLiteral | AssocArrayLiteral
            if (laKind == (OpenSquareBracket))
            {
                Step();
                var startLoc = t.Location;

                // Empty array literal
                if (laKind == CloseSquareBracket)
                {
                    Step();
                    return new ArrayLiteralExpression(null) {Location=startLoc, EndLocation = t.EndLocation };
                }

                /*
                 * If it's an initializer, allow NonVoidInitializers as values.
                 * Normal AssignExpressions otherwise.
                 */
                bool isInitializer = TrackerVariables.IsParsingInitializer;

                var firstExpression = isInitializer? NonVoidInitializer(Scope) : AssignExpression(Scope);

                // Associtative array
                if (laKind == Colon)
                {
                    Step();

                    var ae = isInitializer ?
                        new ArrayInitializer { Location = startLoc } :
                        new AssocArrayExpression { Location=startLoc };
                    LastParsedObject = ae;

                    var firstValueExpression = isInitializer? NonVoidInitializer(Scope) : AssignExpression();

                    ae.Elements.Add(new KeyValuePair<IExpression,IExpression>(firstExpression, firstValueExpression));

                    while (laKind == Comma)
                    {
                        Step();

                        if (laKind == CloseSquareBracket)
                            break;

                        var keyExpr = AssignExpression();
                        var valExpr=Expect(Colon) ?
                            (isInitializer?
                                NonVoidInitializer(Scope) :
                                AssignExpression(Scope)) :
                            null;

                        ae.Elements.Add(new KeyValuePair<IExpression,IExpression>(keyExpr,valExpr));
                    }

                    Expect(CloseSquareBracket);
                    ae.EndLocation = t.EndLocation;
                    return ae;
                }
                else // Normal array literal
                {
                    var ae = new List<IExpression>();
                    LastParsedObject = ae;

                    ae.Add(firstExpression);

                    while (laKind == Comma)
                    {
                        Step();
                        if (laKind == CloseSquareBracket) // And again, empty expressions are allowed
                            break;
                        ae.Add(isInitializer? NonVoidInitializer(Scope) : AssignExpression(Scope));
                    }

                    Expect(CloseSquareBracket);
                    return new ArrayLiteralExpression(ae){ Location=startLoc, EndLocation = t.EndLocation };
                }
            }
            #endregion

            #region FunctionLiteral
            if (laKind == Delegate || laKind == Function || laKind == OpenCurlyBrace || (laKind == OpenParenthesis && IsFunctionLiteral()))
            {
                var fl = new FunctionLiteral() { Location=la.Location};
                LastParsedObject = fl;
                fl.AnonymousMethod.Location = la.Location;

                if (laKind == Delegate || laKind == Function)
                {
                    Step();
                    fl.LiteralToken = t.Kind;
                }

                // file.d:1248
                /*
                    listdir (".", delegate bool (DirEntry * de)
                    {
                        auto s = std.string.format("%s : c %s, w %s, a %s", de.name,
                                toUTCString (de.creationTime),
                                toUTCString (de.lastWriteTime),
                                toUTCString (de.lastAccessTime));
                        return true;
                    }
                    );
                */
                if (laKind != OpenCurlyBrace) // foo( 1, {bar();} ); -> is a legal delegate
                {
                    if (!IsFunctionAttribute && Lexer.CurrentPeekToken.Kind == OpenParenthesis)
                        fl.AnonymousMethod.Type = BasicType();
                    else if (laKind != OpenParenthesis && laKind != OpenCurlyBrace)
                        fl.AnonymousMethod.Type = Type();

                    if (laKind == OpenParenthesis)
                        fl.AnonymousMethod.Parameters = Parameters(fl.AnonymousMethod);

                    FunctionAttributes(fl.AnonymousMethod);
                }

                if(!IsEOF)
                    FunctionBody(fl.AnonymousMethod);

                fl.EndLocation = t.EndLocation;

                if (Scope != null)
                    Scope.Add(fl.AnonymousMethod);

                return fl;
            }
            #endregion

            #region AssertExpression
            if (laKind == (Assert))
            {
                Step();
                var startLoc = t.Location;
                Expect(OpenParenthesis);
                var ce = new AssertExpression() { Location=startLoc};
                LastParsedObject = ce;

                var exprs = new List<IExpression>();
                exprs.Add(AssignExpression());

                if (laKind == (Comma))
                {
                    Step();
                    exprs.Add(AssignExpression());
                }
                ce.AssignExpressions = exprs.ToArray();
                Expect(CloseParenthesis);
                ce.EndLocation = t.EndLocation;
                return ce;
            }
            #endregion

            #region MixinExpression | ImportExpression
            if (laKind == Mixin)
            {
                Step();
                var e = new MixinExpression() { Location=t.Location};
                LastParsedObject = e;
                if (Expect(OpenParenthesis))
                {
                    e.AssignExpression = AssignExpression();
                    Expect(CloseParenthesis);
                }
                e.EndLocation = t.EndLocation;
                return e;
            }

            if (laKind == Import)
            {
                Step();
                var e = new ImportExpression() { Location=t.Location};
                LastParsedObject = e;
                Expect(OpenParenthesis);

                e.AssignExpression = AssignExpression();

                Expect(CloseParenthesis);
                e.EndLocation = t.EndLocation;
                return e;
            }
            #endregion

            if (laKind == (Typeof))
            {
                return new TypeDeclarationExpression(TypeOf());
            }

            // TypeidExpression
            if (laKind == (Typeid))
            {
                Step();
                var ce = new TypeidExpression() { Location=t.Location};
                LastParsedObject = ce;
                Expect(OpenParenthesis);

                if (IsAssignExpression())
                    ce.Expression = AssignExpression(Scope);
                else
                {
                    Lexer.PushLookAheadBackup();
                    AllowWeakTypeParsing = true;
                    ce.Type = Type();
                    AllowWeakTypeParsing = false;

                    if (ce.Type == null || laKind != CloseParenthesis)
                    {
                        Lexer.RestoreLookAheadBackup();
                        ce.Expression = AssignExpression();
                    }
                    else
                        Lexer.PopLookAheadBackup();
                }

                if (!Expect(CloseParenthesis) && IsEOF)
                    LastParsedObject = (ISyntaxRegion)ce.Type ?? ce.Expression;

                ce.EndLocation = t.EndLocation;
                return ce;
            }

            #region IsExpression
            if (laKind == Is)
            {
                Step();
                var ce = new IsExpression() { Location=t.Location};
                LastParsedObject = ce;
                Expect(OpenParenthesis);

                if((ce.TestedType = Type())==null)
                    SynErr(laKind, "In an IsExpression, either a type or an expression is required!");

                if (ce.TestedType!=null && laKind == Identifier && (Lexer.CurrentPeekToken.Kind == CloseParenthesis || Lexer.CurrentPeekToken.Kind == Equal
                    || Lexer.CurrentPeekToken.Kind == Colon))
                {
                    Step();
                    Strings.Add(strVal);
                    ce.TypeAliasIdentifierHash = strVal.GetHashCode();
                    ce.TypeAliasIdLocation = t.Location;
                }

                if (laKind == CloseParenthesis)
                {
                    Step();
                    ce.EndLocation = t.EndLocation;
                    return ce;
                }

                if (laKind == Colon || laKind == Equal)
                {
                    Step();
                    ce.EqualityTest = t.Kind == Equal;
                }
                else if (laKind == CloseParenthesis)
                {
                    Step();
                    ce.EndLocation = t.EndLocation;
                    return ce;
                }

                /*
                TypeSpecialization:
                    Type
                        struct
                        union
                        class
                        interface
                        enum
                        function
                        delegate
                        super
                    const
                    immutable
                    inout
                    shared
                        return
                */

                if (ce.EqualityTest && (ClassLike[laKind] || laKind==Typedef || // typedef is possible although it's not yet documented in the syntax docs
                    laKind==Enum || laKind==Delegate || laKind==Function || laKind==Super || laKind==Return ||
                    ((laKind==Const || laKind == Immutable || laKind == InOut || laKind == Shared) &&
                    (Peek(1).Kind==CloseParenthesis || Lexer.CurrentPeekToken.Kind==Comma))))
                {
                    Step();
                    ce.TypeSpecializationToken = t.Kind;
                }
                else
                    ce.TypeSpecialization = Type();

                // TemplateParameterList
                if (laKind == Comma)
                {
                    var ret = new List<TemplateParameter>();
                    do
                    {
                        Step();
                        ret.Add(TemplateParameter(null));
                    }
                    while (laKind == Comma);
                    ce.TemplateParameterList = ret.ToArray();
                }

                Expect(CloseParenthesis);
                ce.EndLocation = t.EndLocation;
                return ce;
            }
            #endregion

            // NewExpression
            if (laKind == (New))
                return NewExpression(Scope);

            // ( Expression )
            if (laKind == OpenParenthesis)
            {
                Step();
                var ret = new SurroundingParenthesesExpression() {Location=t.Location };
                LastParsedObject = ret;

                ret.Expression = Expression();

                Expect(CloseParenthesis);
                ret.EndLocation = t.EndLocation;
                return ret;
            }

            // TraitsExpression
            if (laKind == (__traits))
                return TraitsExpression();

            #region BasicType . Identifier
            if (IsBasicType())
            {
                var startLoc = la.Location;

                var bt=BasicType();

                if ((bt is TypeOfDeclaration || bt is MemberFunctionAttributeDecl) && laKind!=Dot)
                    return new TypeDeclarationExpression(bt);

                // Things like incomplete 'float.' expressions shall be parseable, too
                if (Expect(Dot) && (Expect(Identifier) || IsEOF))
                    return new PostfixExpression_Access()
                    {
                        PostfixForeExpression = new TypeDeclarationExpression(bt),
                        AccessExpression = string.IsNullOrEmpty(t.Value) ? null : new IdentifierExpression(t.Value) { Location=t.Location, EndLocation=t.EndLocation },
                        EndLocation = t.EndLocation
                    };

                return null;
            }
            #endregion

            SynErr(Identifier);
            if(laKind != CloseCurlyBrace)
                Step();

            // Don't know why, in rare situations, t tends to be null..
            if (t == null)
                return null;
            return new TokenExpression() { Location = t.Location, EndLocation = t.EndLocation };
        }
        /// <summary>
        /// Item1 - True, if isExpression returns true
        /// Item2 - If Item1 is true, it contains the type of the alias that is defined in the isExpression 
        /// </summary>
        private Tuple<bool, AbstractType> evalIsExpression_EvalSpecToken(IsExpression isExpression, AbstractType typeToCheck, bool DoAliasHandling = false)
        {
            bool r = false;
            AbstractType res = null;

            switch (isExpression.TypeSpecializationToken)
            {
                /*
                 * To handle semantic tokens like "return" or "super" it's just needed to
                 * look into the current resolver context -
                 * then, we'll be able to gather either the parent method or the currently scoped class definition.
                 */
                case DTokens.Struct:
                case DTokens.Union:
                case DTokens.Class:
                case DTokens.Interface:
                    if (r = typeToCheck is UserDefinedType &&
                        ((TemplateIntermediateType)typeToCheck).Definition.ClassType == isExpression.TypeSpecializationToken)
                        res = typeToCheck;
                    break;

                case DTokens.Enum:
                    if (!(typeToCheck is EnumType))
                        break;
                    {
                        var tr = (UserDefinedType)typeToCheck;
                        r = true;
                        res = tr.Base;
                    }
                    break;

                case DTokens.Function:
                case DTokens.Delegate:
                    if (typeToCheck is DelegateType)
                    {
                        var isFun = false;
                        var dgr = (DelegateType)typeToCheck;
                        if (!dgr.IsFunctionLiteral)
                            r = isExpression.TypeSpecializationToken == (
                                (isFun = ((DelegateDeclaration)dgr.DeclarationOrExpressionBase).IsFunction) ? DTokens.Function : DTokens.Delegate);
                        // Must be a delegate otherwise
                        else
                            isFun = !(r = isExpression.TypeSpecializationToken == DTokens.Delegate);

                        if (r)
                        {
                            //TODO
                            if (isFun)
                            {
                                // TypeTuple of the function parameter types. For C- and D-style variadic functions, only the non-variadic parameters are included.
                                // For typesafe variadic functions, the ... is ignored.
                            }
                            else
                            {
                                // the function type of the delegate
                            }
                        }
                    }
                    else // Normal functions are also accepted as delegates
                    {
                        r = isExpression.TypeSpecializationToken == DTokens.Delegate &&
                            typeToCheck is MemberSymbol &&
                            ((DSymbol)typeToCheck).Definition is DMethod;

                        //TODO: Alias handling, same as couple of lines above
                    }
                    break;

                case DTokens.Super: //TODO: Test this
                    var dc = DResolver.SearchClassLikeAt(ctxt.ScopedBlock, isExpression.Location) as DClassLike;

                    if (dc != null)
                    {
                        var udt = DResolver.ResolveBaseClasses(new ClassType(dc, dc, null), ctxt, true) as ClassType;

                        if (r = udt.Base != null && ResultComparer.IsEqual(typeToCheck, udt.Base))
                        {
                            var l = new List<AbstractType>();
                            if (udt.Base != null)
                                l.Add(udt.Base);
                            if (udt.BaseInterfaces != null && udt.BaseInterfaces.Length != 0)
                                l.AddRange(udt.BaseInterfaces);

                            res = new DTuple(isExpression, l);
                        }
                    }
                    break;

                case DTokens.Const:
                case DTokens.Immutable:
                case DTokens.InOut: // TODO?
                case DTokens.Shared:
                    if (r = typeToCheck.Modifier == isExpression.TypeSpecializationToken)
                        res = typeToCheck;
                    break;

                case DTokens.Return: // TODO: Test
                    IStatement _u = null;
                    var dm = DResolver.SearchBlockAt(ctxt.ScopedBlock, isExpression.Location, out _u) as DMethod;

                    if (dm != null)
                    {
                        var retType_ = TypeDeclarationResolver.GetMethodReturnType(dm, ctxt);

                        if (r = retType_ != null && ResultComparer.IsEqual(typeToCheck, retType_))
                            res = retType_;
                    }
                    break;
            }

            return new Tuple<bool, AbstractType>(r, res);
        }
Beispiel #55
0
			public override object Visit(Is isExpression)
			{
				var result = new IsExpression();
				if (isExpression.Expr != null)
					result.AddChild((Expression)isExpression.Expr.Accept(this), Roles.Expression);
				result.AddChild(new CSharpTokenNode(Convert(isExpression.Location), IsExpression.IsKeywordRole), IsExpression.IsKeywordRole);
				
				if (isExpression.ProbeType != null)
					result.AddChild(ConvertToType(isExpression.ProbeType), Roles.Type);
				return result;
			}
Beispiel #56
0
 public override void Visit(IsExpression x)
 {
     if (x.TypeAliasIdentifierHash == searchHash &&
         symbol is TemplateParameter.Node &&
         (symbol as TemplateParameter.Node).TemplateParameter == x.ArtificialFirstSpecParam) {
         l.Add (x.ArtificialFirstSpecParam);
     }
     base.Visit (x);
 }
Beispiel #57
0
			public override object Visit (Is isExpression)
			{
				var result = new IsExpression ();
				result.AddChild ((INode)isExpression.Expr.Accept (this), IsExpression.Roles.Expression);
				result.AddChild (new CSharpTokenNode (Convert (isExpression.Location), "is".Length), IsExpression.Roles.Keyword);
				result.AddChild ((INode)isExpression.ProbeType.Accept (this), IsExpression.Roles.ReturnType);
				return result;
			}
Beispiel #58
0
 public StringBuilder VisitIsExpression(IsExpression isExpression, int data)
 {
     throw new SLSharpException("SL# does not have reflection.");
 }
Beispiel #59
0
 public CastBlock(IEmitter emitter, IsExpression isExpression)
     : base(emitter, isExpression)
 {
     this.Emitter = emitter;
     this.IsExpression = isExpression;
 }
		public override void Visit (IsExpression x)
		{
			// is(Type |
			if (x.TypeAliasIdentifierHash == DTokens.IncompleteIdHash && 
				x.TestedType != null && 
				!IsIncompleteDeclaration(x.TestedType)) {
				halt = true;
				explicitlyNoCompletion = true;
			}
			else if (x.TypeSpecializationToken == DTokens.Incomplete)
			{
				prv = new CtrlSpaceCompletionProvider(cdgen, scopedBlock, MemberFilter.Types | MemberFilter.ExpressionKeywords | MemberFilter.StatementBlockKeywords);
				halt = true;
			}
			else
				base.Visit (x);
		}