convertvisitor.cs

SharpDevelop2.0.0 c#开发免费工具

					                               name, typeParameterCount);
				if (typeParameterCount > 0) {
					AST.TypeReferenceCollection arguments = ((AST.GenericTypeReference)reference).GenericArguments;
					// GenericTypeReference derives from SimpleTypeReference
					IReturnType[] typeArguments = new IReturnType[arguments.Count];
					for (int i = 0; i < typeArguments.Length; i++) {
						typeArguments[i] = CreateReturnType(arguments[i], callingClass, callingMember, caretLine, caretColumn,
						                                    projectContent);
					}
					rt = new ConstructedReturnType(rt, typeArguments);
				}
				return rt;
			} else if (reference is AST.CallableTypeReference) {
				AST.CallableTypeReference ctr = (AST.CallableTypeReference)reference;
				AnonymousMethodReturnType amrt = new AnonymousMethodReturnType(new DefaultCompilationUnit(projectContent));
				if (ctr.ReturnType != null) {
					amrt.MethodReturnType = CreateReturnType(ctr.ReturnType, callingClass, callingMember, caretLine, caretColumn, projectContent);
				}
				AddParameters(ctr.Parameters, amrt.MethodParameters, callingMember, callingClass ?? new DefaultClass(new DefaultCompilationUnit(projectContent), "__Dummy"));
				return amrt;
			} else {
				throw new NotSupportedException("unknown reference type: " + reference.ToString());
			}
		}
		IReturnType CreateReturnType(AST.TypeReference reference)
		{
			return CreateReturnType(reference, null);
		}
		IReturnType CreateReturnType(Type type)
		{
			return ReflectionReturnType.CreatePrimitive(type);
		}
		IReturnType CreateReturnType(AST.Field field)
		{
			if (field.Type == null) {
				if (field.Initializer != null)
					return new InferredReturnType(field.Initializer, OuterClass);
				else
					return GetDefaultReturnType(_cu.ProjectContent);
			} else {
				return CreateReturnType(field.Type);
			}
		}
		IReturnType CreateReturnType(AST.Method node, IMethod method)
		{
			if (node.ReturnType == null)
				return new InferredReturnType(node.Body, OuterClass, false);
			return CreateReturnType(node.ReturnType, method);
		}
		IReturnType CreateReturnType(AST.Property property)
		{
			if (property.Type == null && property.Getter != null && property.Getter.Body != null)
				return new InferredReturnType(property.Getter.Body, OuterClass, false);
			return CreateReturnType(property.Type);
		}
		
		public override void OnCallableDefinition(AST.CallableDefinition node)
		{
			LoggingService.Debug("OnCallableDefinition: " + node.FullName);
			DomRegion region = GetRegion(node);
			DefaultClass c = new DefaultClass(_cu, ClassType.Delegate, GetModifier(node), region, OuterClass);
			ConvertAttributes(node, c);
			c.BaseTypes.Add(ReflectionReturnType.CreatePrimitive(typeof(Delegate)));
			c.FullyQualifiedName = node.FullName;
			if (_currentClass.Count > 0) {
				OuterClass.InnerClasses.Add(c);
			} else {
				_cu.Classes.Add(c);
			}
			_currentClass.Push(c); // necessary for CreateReturnType
			ConvertTemplates(node, c);
			IReturnType returnType = CreateReturnType(node.ReturnType);
			DefaultMethod invokeMethod = new DefaultMethod("Invoke", returnType, ModifierEnum.Public, DomRegion.Empty, DomRegion.Empty, c);
			ConvertParameters(node.Parameters, invokeMethod);
			c.Methods.Add(invokeMethod);
			invokeMethod = new DefaultMethod("BeginInvoke", CreateReturnType(typeof(IAsyncResult)), ModifierEnum.Public, DomRegion.Empty, DomRegion.Empty, c);
			ConvertParameters(node.Parameters, invokeMethod);
			if (invokeMethod.Parameters == DefaultParameter.EmptyParameterList) {
				invokeMethod.Parameters = new List<IParameter>();
			}
			invokeMethod.Parameters.Add(new DefaultParameter("callback", CreateReturnType(typeof(AsyncCallback)), DomRegion.Empty));
			invokeMethod.Parameters.Add(new DefaultParameter("object", ReflectionReturnType.Object, DomRegion.Empty));
			c.Methods.Add(invokeMethod);
			invokeMethod = new DefaultMethod("EndInvoke", returnType, ModifierEnum.Public, DomRegion.Empty, DomRegion.Empty, c);
			invokeMethod.Parameters.Add(new DefaultParameter("result", CreateReturnType(typeof(IAsyncResult)), DomRegion.Empty));
			c.Methods.Add(invokeMethod);
			_currentClass.Pop();
		}
		
		public override bool EnterClassDefinition(AST.ClassDefinition node)
		{
			EnterTypeDefinition(node, ClassType.Class);
			return base.EnterClassDefinition(node);
		}
		
		public override bool EnterInterfaceDefinition(AST.InterfaceDefinition node)
		{
			EnterTypeDefinition(node, ClassType.Interface);
			return base.EnterInterfaceDefinition(node);
		}
		
		public override bool EnterEnumDefinition(AST.EnumDefinition node)
		{
			EnterTypeDefinition(node, ClassType.Enum);
			return base.EnterEnumDefinition(node);
		}
		
		public override bool EnterModule(AST.Module node)
		{
			if (!_firstModule && node.Members.Count > 0) {
				EnterTypeDefinition(node, ClassType.Module);
			}
			_firstModule = false;
			return base.EnterModule(node);
		}
		
		private void EnterTypeDefinition(AST.TypeDefinition node, ClassType classType)
		{
			//LoggingService.Debug("Enter " + node.GetType().Name + " (" + node.FullName + ")");
			foreach (AST.Attribute att in node.Attributes) {
				if (att.Name == "Boo.Lang.ModuleAttribute")
					classType = ClassType.Module;
			}
			DomRegion region = GetClientRegion(node);
			DefaultClass c = new DefaultClass(_cu, classType, GetModifier(node), region, OuterClass);
			c.FullyQualifiedName = node.FullName;
			if (_currentClass.Count > 0)
				_currentClass.Peek().InnerClasses.Add(c);
			else
				_cu.Classes.Add(c);
			_currentClass.Push(c);
			ConvertAttributes(node, c);
			ConvertTemplates(node, c);
			if (node.BaseTypes != null) {
				foreach (AST.TypeReference r in node.BaseTypes) {
					c.BaseTypes.Add(CreateReturnType(r));
				}
			}
		}
		
		public override void LeaveClassDefinition(AST.ClassDefinition node)
		{
			LeaveTypeDefinition(node);
			base.LeaveClassDefinition(node);
		}
		
		public override void LeaveInterfaceDefinition(AST.InterfaceDefinition node)
		{
			LeaveTypeDefinition(node);
			base.LeaveInterfaceDefinition(node);
		}
		
		public override void LeaveEnumDefinition(AST.EnumDefinition node)
		{
			LeaveTypeDefinition(node);
			base.LeaveEnumDefinition(node);
		}
		
		public override void LeaveModule(AST.Module node)
		{
			if (_currentClass.Count != 0) LeaveTypeDefinition(node);
			base.LeaveModule(node);
		}
		
		private void LeaveTypeDefinition(AST.TypeDefinition node)
		{
			DefaultClass c = _currentClass.Pop();
			foreach (AST.Attribute att in node.Attributes) {
				if (att.Name == "System.Reflection.DefaultMemberAttribute" && att.Arguments.Count == 1) {
					AST.StringLiteralExpression sle = att.Arguments[0] as AST.StringLiteralExpression;
					if (sle != null) {
						foreach (DefaultProperty p in c.Properties) {
							if (p.Name == sle.Value) {
								p.IsIndexer = true;
							}
						}
					}
				}
			}
			//LoggingService.Debug("Leave "+node.GetType().Name+" "+node.FullName+" (Class = "+c.FullyQualifiedName+")");
		}
		
		public override void OnMethod(AST.Method node)
		{
			//LoggingService.Debug("Method: " + node.FullName + " (" + node.Modifiers + ")");
			DefaultMethod method = new DefaultMethod(node.Name, null, GetModifier(node), GetRegion(node), GetClientRegion(node), OuterClass);
			if ((node.ImplementationFlags & AST.MethodImplementationFlags.Extension) == AST.MethodImplementationFlags.Extension) {
				method.IsExtensionMethod = true;
			}
			ConvertAttributes(node, method);
			ConvertTemplates(node, method);
			// return type must be assign AFTER ConvertTemplates
			method.ReturnType = CreateReturnType(node, method);
			ConvertParameters(node.Parameters, method);
			_currentClass.Peek().Methods.Add(method);
			method.UserData = node;
		}
		
		public override void OnConstructor(AST.Constructor node)
		{
			if (node.IsSynthetic && node.Parameters.Count == 0) return;
			Constructor ctor = new Constructor(GetModifier(node), GetRegion(node), GetClientRegion(node), OuterClass);
			ConvertAttributes(node, ctor);
			ConvertParameters(node.Parameters, ctor);
			_currentClass.Peek().Methods.Add(ctor);
			ctor.UserData = node;
		}
		
		public override void OnEnumMember(AST.EnumMember node)
		{
			DefaultField field = new DefaultField(OuterClass.DefaultReturnType, node.Name, ModifierEnum.Const | ModifierEnum.Public, GetRegion(node), OuterClass);
			ConvertAttributes(node, field);
			OuterClass.Fields.Add(field);
		}
		
		public override void OnField(AST.Field node)
		{
			DefaultField field = new DefaultField(CreateReturnType(node), node.Name, GetModifier(node), GetRegion(node), OuterClass);
			ConvertAttributes(node, field);
			OuterClass.Fields.Add(field);
		}
		
		public override void OnEvent(AST.Event node)
		{
			DomRegion region = GetRegion(node);
			DefaultEvent e = new DefaultEvent(node.Name, CreateReturnType(node.Type), GetModifier(node), region, region, OuterClass);
			ConvertAttributes(node, e);
			OuterClass.Events.Add(e);
		}
		
		public override void OnProperty(AST.Property node)
		{
			DefaultProperty property = new DefaultProperty(node.Name, CreateReturnType(node), GetModifier(node), GetRegion(node), GetClientRegion(node), OuterClass);
			ConvertAttributes(node, property);
			ConvertParameters(node.Parameters, property);
			if (node.Getter != null && node.Getter.Body != null) {
				property.GetterRegion = GetClientRegion(node.Getter);
			}
			if (node.Setter != null && node.Setter.Body != null) {
				property.SetterRegion = GetClientRegion(node.Setter);
			}
			OuterClass.Properties.Add(property);
			property.UserData = node;
		}
	}
}