/// <summary>
        /// Expands the specified macro.
        /// </summary>
        /// <param name="macro">The macro.</param>
        /// <returns></returns>
        public override Statement Expand(MacroStatement macro)
        {
            Property property = new Property(propertyName);
            property.LexicalInfo = macro.LexicalInfo;
            property.Getter = new Method();
            if(macro.Arguments.Count==1)
            {
                property.Getter.Body.Add(
                    new ReturnStatement(macro.Arguments[0])
                    );
            }
            else if(
                macro.Arguments.Count == 0 &&
                macro.Body != null &&
				macro.Body.IsEmpty == false)//use the macro block
            {
				property.Getter.Body = macro.Body;
            }
            else
            {
                CompilerErrorFactory.CustomError(macro.LexicalInfo,
                                                 macro.Name + " must have a single expression argument or a block");
                return null;
            }

            ClassDefinition clazz = (ClassDefinition) macro.GetAncestor(NodeType.ClassDefinition);
            clazz.Members.Add(property);

            return null;
        }
Exemplo n.º 2
0
		override public void LeaveProperty(Property node)
		{
			MakeStaticIfNeeded(node);
			CantBeMarkedTransient(node);
			CantBeMarkedPartial(node);
			CheckExplicitImpl(node);
			CheckModifierCombination(node);
		}
Exemplo n.º 3
0
 IReturnType CreateReturnType(AST.Property property)
 {
     if (property.Type == null && property.Getter != null && property.Getter.Body != null)
     {
         return(new BooInferredReturnType(property.Getter.Body, OuterClass, false));
     }
     return(CreateReturnType(property.Type));
 }
 protected override void ExtendBaseClass(TypeDefinition definition)
 {
     Property property = new Property("Environment");
     property.Getter = new Method("getter_Environment");
     property.Getter.Body.Add(
         new ReturnStatement(
             new StringLiteralExpression(environment ?? "")
             )
         );
     definition.Members.Add(property);
 }
Exemplo n.º 5
0
		override public void Apply(Node node)
		{
			Field f = (Field)node;

			Property p = new Property();
			p.Name = f.Name;
			p.Type = f.Type;
			p.Setter = CreateSetter(f);
			p.Getter = CreateGetter(f);

			((TypeDefinition)f.ParentNode).Members.Replace(f, p);			
		}
		// get the directory name where this script reside and create a property
		// that return this value.
		// this is used to calculate relative paths when loading subviews.
		private void ScriptDirectoryProperty(ClassDefinition macro, Module module)
		{
			Property p = new Property("ScriptDirectory");
			p.Modifiers = TypeMemberModifiers.Override;
			p.Getter = new Method("getScriptDirectory");
			p.Getter.Body.Add(
				new ReturnStatement(
					new StringLiteralExpression(
						Path.GetDirectoryName(module.LexicalInfo.FileName))));

			macro.Members.Add(p);
		}
Exemplo n.º 7
0
 private DomRegion GetClientRegion(AST.Node m)
 {
     AST.LexicalInfo l = m.LexicalInfo;
     if (l.Line < 0)
     {
         return(DomRegion.Empty);
     }
     AST.SourceLocation l2;
     if (m is AST.Method)
     {
         l2 = ((AST.Method)m).Body.EndSourceLocation;
     }
     else if (m is AST.Property)
     {
         AST.Property p = (AST.Property)m;
         if (p.Getter != null && p.Getter.Body != null)
         {
             l2 = p.Getter.Body.EndSourceLocation;
             if (p.Setter != null && p.Setter.Body != null)
             {
                 if (p.Setter.Body.EndSourceLocation.Line > l2.Line)
                 {
                     l2 = p.Setter.Body.EndSourceLocation;
                 }
             }
         }
         else if (p.Setter != null && p.Setter.Body != null)
         {
             l2 = p.Setter.Body.EndSourceLocation;
         }
         else
         {
             l2 = p.EndSourceLocation;
         }
     }
     else
     {
         l2 = m.EndSourceLocation;
     }
     if (l2 == null || l2.Line < 0 || l.Line == l2.Line)
     {
         return(DomRegion.Empty);
     }
     // TODO: use l.Column / l2.Column when the tab-bug has been fixed
     return(new DomRegion(l.Line, GetLineEnd(l.Line), l2.Line, GetLineEnd(l2.Line)));
 }
Exemplo n.º 8
0
        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);
            }
            property.IsIndexer = (node.Name == "self");
            OuterClass.Properties.Add(property);
            property.UserData = node;
        }
 public object VisitPropertyDeclaration(PropertyDeclaration propertyDeclaration, object data)
 {
     B.Property m = new B.Property(GetLexicalInfo(propertyDeclaration));
     m.Name      = propertyDeclaration.Name;
     m.Modifiers = ConvertModifier(propertyDeclaration, B.TypeMemberModifiers.Private);
     ConvertAttributes(propertyDeclaration.Attributes, m.Attributes);
     if (currentType != null)
     {
         currentType.Members.Add(m);
     }
     ConvertParameters(propertyDeclaration.Parameters, m.Parameters);
     if (propertyDeclaration.IsIndexer)
     {
         m.Name = "self";
     }
     m.EndSourceLocation = GetLocation(propertyDeclaration.EndLocation);
     m.Type         = ConvertTypeReference(propertyDeclaration.TypeReference);
     m.ExplicitInfo = ConvertInterfaceImplementations(propertyDeclaration.InterfaceImplementations, propertyDeclaration, m);
     if (!propertyDeclaration.IsWriteOnly)
     {
         m.Getter = new B.Method(GetLexicalInfo(propertyDeclaration.GetRegion));
         if (propertyDeclaration.GetRegion != null)
         {
             ConvertAttributes(propertyDeclaration.GetRegion.Attributes, m.Getter.Attributes);
             m.Getter.Modifiers  = ConvertModifier(propertyDeclaration.GetRegion, B.TypeMemberModifiers.None);
             m.Getter.Body       = ConvertMethodBlock(propertyDeclaration.GetRegion.Block);
             m.Getter.ReturnType = m.Type;
         }
     }
     if (!propertyDeclaration.IsReadOnly)
     {
         m.Setter = new B.Method(GetLexicalInfo(propertyDeclaration.SetRegion));
         if (propertyDeclaration.SetRegion != null)
         {
             ConvertAttributes(propertyDeclaration.SetRegion.Attributes, m.Setter.Attributes);
             m.Setter.Modifiers = ConvertModifier(propertyDeclaration.SetRegion, B.TypeMemberModifiers.None);
             m.Setter.Body      = ConvertMethodBlock(propertyDeclaration.SetRegion.Block);
         }
     }
     return(m);
 }
		void SetPropertyAccessorModifiers(Property property, Method accessor)
		{
			if (!accessor.IsVisibilitySet)
				accessor.Modifiers |= property.Visibility;
			
			if (property.IsStatic)
				accessor.Modifiers |= TypeMemberModifiers.Static;
			
			if (property.IsVirtual)
				accessor.Modifiers |= TypeMemberModifiers.Virtual;
			
			if (property.IsAbstract)
				accessor.Modifiers |= TypeMemberModifiers.Abstract;
			else if (accessor.IsAbstract)
				// an abstract accessor makes the entire property abstract
				property.Modifiers |= TypeMemberModifiers.Abstract;
		}
Exemplo n.º 11
0
		override public object Clone()
		{
		
			Property clone = new Property();
			clone._lexicalInfo = _lexicalInfo;
			clone._endSourceLocation = _endSourceLocation;
			clone._documentation = _documentation;
			clone._isSynthetic = _isSynthetic;
			clone._entity = _entity;
			if (_annotations != null) clone._annotations = (Hashtable)_annotations.Clone();
			clone._modifiers = _modifiers;
			clone._name = _name;
			if (null != _attributes)
			{
				clone._attributes = _attributes.Clone() as AttributeCollection;
				clone._attributes.InitializeParent(clone);
			}
			if (null != _parameters)
			{
				clone._parameters = _parameters.Clone() as ParameterDeclarationCollection;
				clone._parameters.InitializeParent(clone);
			}
			if (null != _getter)
			{
				clone._getter = _getter.Clone() as Method;
				clone._getter.InitializeParent(clone);
			}
			if (null != _setter)
			{
				clone._setter = _setter.Clone() as Method;
				clone._setter.InitializeParent(clone);
			}
			if (null != _type)
			{
				clone._type = _type.Clone() as TypeReference;
				clone._type.InitializeParent(clone);
			}
			if (null != _explicitInfo)
			{
				clone._explicitInfo = _explicitInfo.Clone() as ExplicitMemberInfo;
				clone._explicitInfo.InitializeParent(clone);
			}
			return clone;


		}
		public object VisitPropertyDeclaration(PropertyDeclaration propertyDeclaration, object data)
		{
			B.Property m = new B.Property(GetLexicalInfo(propertyDeclaration));
			m.Name = propertyDeclaration.Name;
			m.Modifiers = ConvertModifier(propertyDeclaration, B.TypeMemberModifiers.Private);
			ConvertAttributes(propertyDeclaration.Attributes, m.Attributes);
			if (currentType != null) currentType.Members.Add(m);
			ConvertParameters(propertyDeclaration.Parameters, m.Parameters);
			if (propertyDeclaration.IsIndexer) m.Name = "self";
			m.EndSourceLocation = GetLocation(propertyDeclaration.EndLocation);
			m.Type = ConvertTypeReference(propertyDeclaration.TypeReference);
			m.ExplicitInfo = ConvertInterfaceImplementations(propertyDeclaration.InterfaceImplementations, propertyDeclaration, m);
			if (!propertyDeclaration.IsWriteOnly) {
				m.Getter = new B.Method(GetLexicalInfo(propertyDeclaration.GetRegion));
				if (propertyDeclaration.GetRegion != null) {
					ConvertAttributes(propertyDeclaration.GetRegion.Attributes, m.Getter.Attributes);
					m.Getter.Modifiers = ConvertModifier(propertyDeclaration.GetRegion, B.TypeMemberModifiers.None);
					m.Getter.Body = ConvertMethodBlock(propertyDeclaration.GetRegion.Block);
					m.Getter.ReturnType = m.Type;
				}
			}
			if (!propertyDeclaration.IsReadOnly) {
				m.Setter = new B.Method(GetLexicalInfo(propertyDeclaration.SetRegion));
				if (propertyDeclaration.SetRegion != null) {
					ConvertAttributes(propertyDeclaration.SetRegion.Attributes, m.Setter.Attributes);
					m.Setter.Modifiers = ConvertModifier(propertyDeclaration.SetRegion, B.TypeMemberModifiers.None);
					m.Setter.Body = ConvertMethodBlock(propertyDeclaration.SetRegion.Block);
				}
			}
			return m;
		}
		protected IProperty GetEntity(Property node)
		{
			return (IProperty)TypeSystemServices.GetEntity(node);
		}
Exemplo n.º 14
0
 public override void OnProperty(Property node)
 {
     node.Name = node.Name.TrimStart('@');
     base.OnProperty(node);
 }
        void SetPropertyAccessorModifiers(Property property, Method accessor)
        {
            if (!accessor.IsVisibilitySet)
            {
                accessor.Modifiers |= property.Visibility;
            }

            if (property.IsStatic)
            {
                accessor.Modifiers |= TypeMemberModifiers.Static;
            }

            if (property.IsVirtual)
            {
                accessor.Modifiers |= TypeMemberModifiers.Virtual;
            }

            /*
            if (property.IsOverride)
            {
                accessor.Modifiers |= TypeMemberModifiers.Override;
            }
            */

            if (property.IsAbstract)
            {
                accessor.Modifiers |= TypeMemberModifiers.Abstract;
            }
            else if (accessor.IsAbstract)
            {
                // an abstract accessor makes the entire property abstract
                property.Modifiers |= TypeMemberModifiers.Abstract;
            }
        }
		private void NormalizeDefaultItemProperty(Property node)
		{
			if (!IsDefaultItemProperty(node)) return;

			node.Name = "Item";
			TypeDefinition declaringType = node.DeclaringType;
			if (declaringType != null) AddDefaultMemberAttribute(declaringType, node);
		}
Exemplo n.º 17
0
 public override void OnProperty(Property node)
 {
 }
        public override void LeaveProperty(Property node)
        {
            if (!node.IsVisibilitySet && null == node.ExplicitInfo)
            {
                node.Modifiers |= TypeMemberModifiers.Public;
            }
            if (IsInterface(node.DeclaringType))
            {
                node.Modifiers |= TypeMemberModifiers.Abstract;
            }

            if (null != node.Getter)
            {
                SetPropertyAccessorModifiers(node, node.Getter);
                node.Getter.Name = "get_" + node.Name;
            }
            if (null != node.Setter)
            {
                SetPropertyAccessorModifiers(node, node.Setter);
                node.Setter.Name = "set_" + node.Name;
            }

            LeaveMember(node);
        }
		// get the original file name for this script and create a property
		// that return this value.
		private void ViewFileNameProperty(ClassDefinition macro, Module module)
		{
			var p = new Property("ViewFileName")
			{
				Modifiers = TypeMemberModifiers.Override,
				Getter = new Method("getViewFileName")
			};
			p.Getter.Body.Add(
				new ReturnStatement(
					new StringLiteralExpression(module.LexicalInfo.FileName)));

			macro.Members.Add(p);
		}
            protected override Statement ExpandImpl(MacroStatement macro)
            {
                Module module = macro.findModule();

                string propname = "";
                TypeReference type = new SimpleTypeReference("System.Object");
                Expression initializer = null;

                if (macro.Arguments[0] is BinaryExpression)
                {
                    var bin = macro.Arguments[0] as BinaryExpression;
                    initializer = bin.Right;
                    if (bin.Left is TryCastExpression)
                    {
                        var tce = bin.Left as TryCastExpression;
                        propname = tce.Target.ToCodeString();
                        type = tce.Type ?? type;
                    }
                    //else
                    //{
                    //    propname = bin.Left.ToCodeString();
                    //}
                }
                //else
                //{
                //    propname = macro.Arguments[0].ToCodeString();
                //}

                var geter = new Method("get_" + propname);
                geter.ReturnType = type;
                geter.Body = new Block();
                if (initializer != null)
                {
                    geter.Body.add(
                        new IfStatement(
                            new BinaryExpression(
                                BinaryOperatorType.Equality,
                                new NullLiteralExpression(),
                                new MethodInvocationExpression(
                                    new ReferenceExpression("TryGetParameterNoIgnoreNull"),
                                    new StringLiteralExpression(propname))
                                ),
                            new Block().add(new MethodInvocationExpression(
                                                new ReferenceExpression("SetProperty"),
                                                new StringLiteralExpression(propname),
                                                initializer ?? new NullLiteralExpression()))
                            , null
                            )
                        );
                }


                var convertmethod = new GenericReferenceExpression();
                convertmethod.Target = new ReferenceExpression("_convert");
                convertmethod.GenericArguments.Add(type);
                var valuecall = new MethodInvocationExpression(
                    new ReferenceExpression("TryGetParameterNoIgnoreNull"),
                    new StringLiteralExpression(propname));
                var convertcall = new MethodInvocationExpression(convertmethod,valuecall);
                
                geter.Body.add(new ReturnStatement(new CastExpression(convertcall, type)));

                var seter = new Method("set_" + propname);
                seter.Body = new Block().add(new MethodInvocationExpression(
                                                 new ReferenceExpression("SetProperty"),
                                                 new StringLiteralExpression(propname),
                                                 new ReferenceExpression("value")));

                var prop = new Property(geter, seter, type);
                prop.Name = propname;
                //try
                //{
                    ((TypeDefinition)module.Members[0]).Members.Insert(0, prop);
                //}
                //catch
                //{
                //    module.Members.Insert(0, prop); //in test env
                //}
                return null;
            }
		private void AddDefaultMemberAttribute(TypeDefinition type, Property node)
		{
			if (!ContainsDefaultMemberAttribute(type))
			{
				Attribute attribute = CodeBuilder.CreateAttribute(
					DefaultMemberAttributeStringConstructor(), 
					new StringLiteralExpression(node.Name));
				attribute.LexicalInfo = node.LexicalInfo;
				type.Attributes.Add(attribute);
			}
		}
		private void NormalizePropertyModifiers(Property node)
		{
			if (IsInterfaceMember(node))
				node.Modifiers = TypeMemberModifiers.Public | TypeMemberModifiers.Abstract;
			else if (!node.IsVisibilitySet && null == node.ExplicitInfo)
				node.Modifiers |= Context.Parameters.DefaultPropertyVisibility;

			if (null != node.Getter)
			{
				SetPropertyAccessorModifiers(node, node.Getter);
				node.Getter.Name = "get_" + node.Name;
			}
			if (null != node.Setter)
			{
				SetPropertyAccessorModifiers(node, node.Setter);
				node.Setter.Name = "set_" + node.Name;
			}
		}
		private static bool IsDefaultItemProperty(Property node)
		{
			return (node.Name == "Item" || node.Name == "self")
				&& node.Parameters.Count > 0
				&& !node.IsStatic;
		}
		override public void LeaveProperty(Property node)
		{
			NormalizeDefaultItemProperty(node);
			NormalizePropertyModifiers(node);
			LeaveMember(node);
		}
Exemplo n.º 25
0
 public InternalProperty(TypeSystemServices typeSystemServices, Property property)
 {
     _typeSystemServices = typeSystemServices;
     _property = property;
 }
Exemplo n.º 26
0
 public override void LeaveProperty(Property node)
 {
     CheckName(node,node.Name);
 }
Exemplo n.º 27
0
		override public void LeaveProperty(Property node)
		{
			LeaveMember(node);
		}