コード例 #1
0
 static void setBoxing(CompilerContext context, TypeInfo targetType, ExpressionNode expression) {
     var info = expression.getUserData(typeof(ExpressionInfo));
     if (info == null || targetType == null) {
         return;
     }
     var type = getType(context, expression);
     if (type == targetType) {
         return;
     }
     if (isAssignable(context, targetType, expression)) {
         if (targetType.IsPrimitive) {
             if (!type.IsPrimitive) {
                 info.BoxingKind = BoxingKind.Unbox;
                 var unboxinMethod = context.TypeSystem.getUnboxingMethod(type);
                 info.BoxingMethod = unboxinMethod;
                 info.OriginalType = info.Type;
                 info.Type = unboxinMethod.ReturnType;
             }
         } else if (type.IsPrimitive) {
             info.BoxingKind = BoxingKind.Box;
             var boxingMethod = context.TypeSystem.getBoxingMethod((targetType.IsObject) ? type : targetType);
             info.BoxingMethod = boxingMethod;
             info.OriginalType = info.Type;
             info.Type = boxingMethod.ReturnType;
         } else if (targetType.IsNumeric && type.IsNumeric) {
             info.BoxingKind = BoxingKind.Unbox;
             info.BoxingMethod = context.TypeSystem.getUnboxingMethod(type);
         }
     }
 }
コード例 #2
0
 static TypeInfo getVariableType(CompilerContext context, TypeInfo type) {
     switch (type.TypeKind) {
     case LowerBoundedWildcard:
     case UnboundedWildcard:
         return context.TypeSystem.ObjectType;
     default:
         return type;
     }
 }
コード例 #3
0
 DocumentationBuilder(CompilerContext context, Element members) {
     this.context = context;
     this.members = members;
     this.document = members.getOwnerDocument();
 }
コード例 #4
0
        static TypeInfo getType(CompilerContext context, ExpressionNode expression) {
            if (ValidationHelper.isMethod(expression)) {
                throw context.error(CompileErrorId.UnexpectedMethodReference, expression);
            }
            var info = expression.getUserData(typeof(ExpressionInfo));
            if (info.Type != null) {
                return info.Type;
            } else if (info.IsConstant) {
                context.ConstantBuilder.buildConstant(expression);
                return info.Type;
            } else if (info.Members != null) {
                foreach (var member in info.Members) {
                    switch (member.MemberKind) {
                    case Field:
                        var field = member.Field;
                        if (field.Value != null) {
                            info.IsConstant = true;
                            info.Value = field.Value;
                        }
                        info.Member = member;
                        info.Type = member.Type;
                        if (!isInDeprecatedContext(context)) {
							if (BytecodeHelper.isDeprecated(context.AnnotatedTypeSystem, field)) {
								context.addWarning(CompileErrorId.DeprecatedField, expression,
										BytecodeHelper.getDisplayName(field.DeclaringType), field.Name);
							}
                        }
						if (context.CodeValidationContext.IsInMethod && context.CodeValidationContext.IsInLambda) {
	                    	if (!member.IsStatic && expression.ExpressionKind == ExpressionKind.SimpleName) {
				                var typeBuilder = context.LambdaScopes[context.CodeValidationContext.RootMethod];
				                if (typeBuilder.getField("this$0") == null) {
				                    typeBuilder.defineField("this$0", context.CurrentType);
				                }
	                    	}
                    	}
                        return member.Type;
                        
                    case Type:
                        info.Member = member;
                        info.Type = member.Type;
                        if (!isInDeprecatedContext(context)) {
							if (BytecodeHelper.isDeprecated(context.AnnotatedTypeSystem, info.Type)) {
								context.addWarning(CompileErrorId.DeprecatedType, expression,
										BytecodeHelper.getDisplayName(info.Type));
							}
						}
                        return member.Type;
						
                    case Indexer:
                    case Property:
                        info.Member = member;
                        info.Type = member.Type;
                        if (!isInDeprecatedContext(context)) {
							if (member.GetAccessor != null) {
								if (member.SetAccessor == null) {
									if (BytecodeHelper.isDeprecated(context.AnnotatedTypeSystem, member.GetAccessor)) {
										context.addWarning(CompileErrorId.DeprecatedProperty, expression,
												BytecodeHelper.getDisplayName(member.DeclaringType), member.Name);
									}
								} else {
									if (BytecodeHelper.isDeprecated(context.AnnotatedTypeSystem, member.GetAccessor) &&
											BytecodeHelper.isDeprecated(context.AnnotatedTypeSystem, member.SetAccessor)) {
										context.addWarning(CompileErrorId.DeprecatedProperty, expression,
												BytecodeHelper.getDisplayName(member.DeclaringType), member.Name);
									}
								}
							} else if (member.SetAccessor != null) {
								if (BytecodeHelper.isDeprecated(context.AnnotatedTypeSystem, member.SetAccessor)) {
									context.addWarning(CompileErrorId.DeprecatedProperty, expression,
											BytecodeHelper.getDisplayName(member.DeclaringType), member.Name);
								}
							}
						}
						if (context.CodeValidationContext.IsInMethod && context.CodeValidationContext.IsInLambda) {
	                    	if (!member.IsStatic && expression.ExpressionKind == ExpressionKind.SimpleName) {
				                var typeBuilder = context.LambdaScopes[context.CodeValidationContext.RootMethod];
				                if (typeBuilder.getField("this$0") == null) {
				                    typeBuilder.defineField("this$0", context.CurrentType);
				                }
	                    	}
                    	}
                        return member.Type;
                        
                    case Local:
						if (context.CodeValidationContext.IsInMethod) {
	                        var currentMethod = context.CodeValidationContext.CurrentMethod;
	                      	var currentType = (TypeBuilder)currentMethod.DeclaringType;
	                        if (currentType.FullName.indexOf('#') == -1 && context.CodeValidationContext.IsInLambda) {
		                        if (currentMethod != member.Method) {
		                            member.IsUsedFromLambda = true;
					                var typeBuilder = context.LambdaScopes[context.CodeValidationContext.RootMethod];
					                context.getLocalField(typeBuilder, (LocalMemberInfo)member);
		                        }
	                        }
                        }
                        info.Member = member;
                        info.Type = member.Type;
                        return member.Type;
                        
                    default:
                        break;
                    }
                }
                if (info.ExtensionMethods != null && info.ExtensionMethods.any()) {
                    return info.Type = info.ExtensionMethods.first().Parameters.first().Type;
                }
            }
            throw new Exception("Internal error line " + (expression.getLine() + 1));
        }
コード例 #5
0
		private static bool isInDeprecatedContext(CompilerContext context) {
			if (!BytecodeHelper.isDeprecated(context.AnnotatedTypeSystem, context.CurrentType)) {
				if (!context.CodeValidationContext.IsInMethod || !BytecodeHelper.isDeprecated(context.AnnotatedTypeSystem,
						context.CodeValidationContext.RootMethod)) {
					return false;
				}
			}
			return true;
		}
コード例 #6
0
 static bool isAssignable(CompilerContext context, TypeInfo type, ExpressionNode expression) {
     var info = expression.getUserData(typeof(ExpressionInfo));
     if (info == null) {
         return !type.IsPrimitive;
     }
     var right = getType(context, expression);
     if (type.isAssignableFrom(right)) {
         return true;
     }
     if (expression.ExpressionKind == ExpressionKind.ArrayInitializer) {
         if (!type.IsArray) {
             return false;
         }
         foreach (var e in ((ArrayInitializerExpressionNode)expression).Values) {
             if (!isAssignable(context, type.ElementType, e)) {
                 return false;
             }
         }
         return true;
     }
     if (type.IsNumeric && info.IsConstant) {
         switch (type.NumericTypeKind) {
         case Byte: {
             long value;
             switch (right.TypeKind) {
             case Char:
                 value = ((Character)info.Value).charValue();
                 break;
             case Int:
             case Long:
             case Short:
                 value = ((Number)info.Value).longValue();
                 break;
             default:
                 return false;
             }
             return Byte.MIN_VALUE <= value && value <= Byte.MAX_VALUE;
         }
         case Char: {
             long value;
             switch (right.TypeKind) {
             case Byte:
             case Int:
             case Long:
             case Short:
                 value = ((Number)info.Value).longValue();
                 break;
             default:
                 return false;
             }
             return Character.MIN_VALUE <= value && value <= Character.MAX_VALUE;
         }
         case Short: {
             long value;
             switch (right.TypeKind) {
             case Byte:
                 return true;
             case Char:
                 value = ((Character)info.Value).charValue();
                 break;
             case Int:
             case Long:
                 value = ((Number)info.Value).longValue();
                 break;
             default:
                 return false;
             }
             return Short.MIN_VALUE <= value && value <= Short.MAX_VALUE;
         }
         case Int: {
             long value;
             switch (right.getTypeKind()) {
             case Char:
                 value = ((Character)info.Value).charValue();
                 break;
             case Byte:
             case Short:
                 return true;
             case Long:
                 value = ((Number)info.getValue()).longValue();
                 break;
             default:
                 return false;
             }
             return Integer.MIN_VALUE <= value && value <= Integer.MAX_VALUE;
         }
         }
     }
     return false;
 }
コード例 #7
0
        static bool isAssignable(CompilerContext context, TypeInfo type, ExpressionNode expression)
        {
            var info = expression.getUserData(typeof(ExpressionInfo));

            if (info == null)
            {
                return(!type.IsPrimitive);
            }
            var right = getType(context, expression);

            if (type.isAssignableFrom(right))
            {
                return(true);
            }
            if (expression.ExpressionKind == ExpressionKind.ArrayInitializer)
            {
                if (!type.IsArray)
                {
                    return(false);
                }
                foreach (var e in ((ArrayInitializerExpressionNode)expression).Values)
                {
                    if (!isAssignable(context, type.ElementType, e))
                    {
                        return(false);
                    }
                }
                return(true);
            }
            if (type.IsNumeric && info.IsConstant)
            {
                switch (type.NumericTypeKind)
                {
                case Byte: {
                    long value;
                    switch (right.TypeKind)
                    {
                    case Char:
                        value = ((Character)info.Value).charValue();
                        break;

                    case Int:
                    case Long:
                    case Short:
                        value = ((Number)info.Value).longValue();
                        break;

                    default:
                        return(false);
                    }
                    return(Byte.MIN_VALUE <= value && value <= Byte.MAX_VALUE);
                }

                case Char: {
                    long value;
                    switch (right.TypeKind)
                    {
                    case Byte:
                    case Int:
                    case Long:
                    case Short:
                        value = ((Number)info.Value).longValue();
                        break;

                    default:
                        return(false);
                    }
                    return(Character.MIN_VALUE <= value && value <= Character.MAX_VALUE);
                }

                case Short: {
                    long value;
                    switch (right.TypeKind)
                    {
                    case Byte:
                        return(true);

                    case Char:
                        value = ((Character)info.Value).charValue();
                        break;

                    case Int:
                    case Long:
                        value = ((Number)info.Value).longValue();
                        break;

                    default:
                        return(false);
                    }
                    return(Short.MIN_VALUE <= value && value <= Short.MAX_VALUE);
                }

                case Int: {
                    long value;
                    switch (right.getTypeKind())
                    {
                    case Char:
                        value = ((Character)info.Value).charValue();
                        break;

                    case Byte:
                    case Short:
                        return(true);

                    case Long:
                        value = ((Number)info.getValue()).longValue();
                        break;

                    default:
                        return(false);
                    }
                    return(Integer.MIN_VALUE <= value && value <= Integer.MAX_VALUE);
                }
                }
            }
            return(false);
        }
コード例 #8
0
        static TypeInfo getType(CompilerContext context, ExpressionNode expression)
        {
            if (ValidationHelper.isMethod(expression))
            {
                throw context.error(CompileErrorId.UnexpectedMethodReference, expression);
            }
            var info = expression.getUserData(typeof(ExpressionInfo));

            if (info.Type != null)
            {
                return(info.Type);
            }
            else if (info.IsConstant)
            {
                context.ConstantBuilder.buildConstant(expression);
                return(info.Type);
            }
            else if (info.Members != null)
            {
                foreach (var member in info.Members)
                {
                    switch (member.MemberKind)
                    {
                    case Field:
                        var field = member.Field;
                        if (field.Value != null)
                        {
                            info.IsConstant = true;
                            info.Value      = field.Value;
                        }
                        info.Member = member;
                        info.Type   = member.Type;
                        if (!isInDeprecatedContext(context))
                        {
                            if (BytecodeHelper.isDeprecated(context.AnnotatedTypeSystem, field))
                            {
                                context.addWarning(CompileErrorId.DeprecatedField, expression,
                                                   BytecodeHelper.getDisplayName(field.DeclaringType), field.Name);
                            }
                        }
                        if (context.CodeValidationContext.IsInMethod && context.CodeValidationContext.IsInLambda)
                        {
                            if (!member.IsStatic && expression.ExpressionKind == ExpressionKind.SimpleName)
                            {
                                var typeBuilder = context.LambdaScopes[context.CodeValidationContext.RootMethod];
                                if (typeBuilder.getField("this$0") == null)
                                {
                                    typeBuilder.defineField("this$0", context.CurrentType);
                                }
                            }
                        }
                        return(member.Type);

                    case Type:
                        info.Member = member;
                        info.Type   = member.Type;
                        if (!isInDeprecatedContext(context))
                        {
                            if (BytecodeHelper.isDeprecated(context.AnnotatedTypeSystem, info.Type))
                            {
                                context.addWarning(CompileErrorId.DeprecatedType, expression,
                                                   BytecodeHelper.getDisplayName(info.Type));
                            }
                        }
                        return(member.Type);

                    case Indexer:
                    case Property:
                        info.Member = member;
                        info.Type   = member.Type;
                        if (!isInDeprecatedContext(context))
                        {
                            if (member.GetAccessor != null)
                            {
                                if (member.SetAccessor == null)
                                {
                                    if (BytecodeHelper.isDeprecated(context.AnnotatedTypeSystem, member.GetAccessor))
                                    {
                                        context.addWarning(CompileErrorId.DeprecatedProperty, expression,
                                                           BytecodeHelper.getDisplayName(member.DeclaringType), member.Name);
                                    }
                                }
                                else
                                {
                                    if (BytecodeHelper.isDeprecated(context.AnnotatedTypeSystem, member.GetAccessor) &&
                                        BytecodeHelper.isDeprecated(context.AnnotatedTypeSystem, member.SetAccessor))
                                    {
                                        context.addWarning(CompileErrorId.DeprecatedProperty, expression,
                                                           BytecodeHelper.getDisplayName(member.DeclaringType), member.Name);
                                    }
                                }
                            }
                            else if (member.SetAccessor != null)
                            {
                                if (BytecodeHelper.isDeprecated(context.AnnotatedTypeSystem, member.SetAccessor))
                                {
                                    context.addWarning(CompileErrorId.DeprecatedProperty, expression,
                                                       BytecodeHelper.getDisplayName(member.DeclaringType), member.Name);
                                }
                            }
                        }
                        if (context.CodeValidationContext.IsInMethod && context.CodeValidationContext.IsInLambda)
                        {
                            if (!member.IsStatic && expression.ExpressionKind == ExpressionKind.SimpleName)
                            {
                                var typeBuilder = context.LambdaScopes[context.CodeValidationContext.RootMethod];
                                if (typeBuilder.getField("this$0") == null)
                                {
                                    typeBuilder.defineField("this$0", context.CurrentType);
                                }
                            }
                        }
                        return(member.Type);

                    case Local:
                        if (context.CodeValidationContext.IsInMethod)
                        {
                            var currentMethod = context.CodeValidationContext.CurrentMethod;
                            var currentType   = (TypeBuilder)currentMethod.DeclaringType;
                            if (currentType.FullName.indexOf('#') == -1 && context.CodeValidationContext.IsInLambda)
                            {
                                if (currentMethod != member.Method)
                                {
                                    member.IsUsedFromLambda = true;
                                    var typeBuilder = context.LambdaScopes[context.CodeValidationContext.RootMethod];
                                    context.getLocalField(typeBuilder, (LocalMemberInfo)member);
                                }
                            }
                        }
                        info.Member = member;
                        info.Type   = member.Type;
                        return(member.Type);

                    default:
                        break;
                    }
                }
                if (info.ExtensionMethods != null && info.ExtensionMethods.any())
                {
                    return(info.Type = info.ExtensionMethods.first().Parameters.first().Type);
                }
            }
            throw new Exception("Internal error line " + (expression.getLine() + 1));
        }
コード例 #9
0
     : super(true)
 {
     this.context = context;
 }
コード例 #10
0
 StatementValidator(CompilerContext context)
     : super(true)
コード例 #11
0
 MethodResolver(ExpressionValidator expressionValidator, CompilerContext context) {
     this.expressionValidator = expressionValidator;
     this.context = context;
 }