Inheritance: AttributedNode
Example #1
0
        public override object VisitIndexerDeclaration(AST.IndexerDeclaration indexerDeclaration, object data)
        {
            DomRegion       region     = GetRegion(indexerDeclaration.StartLocation, indexerDeclaration.EndLocation);
            DomRegion       bodyRegion = GetRegion(indexerDeclaration.BodyStart, indexerDeclaration.BodyEnd);
            DefaultProperty i          = new DefaultProperty("Indexer", CreateReturnType(indexerDeclaration.TypeReference), ConvertModifier(indexerDeclaration.Modifier), region, bodyRegion, GetCurrentClass());

            i.IsIndexer = true;
            if (indexerDeclaration.HasGetRegion)
            {
                i.GetterRegion    = GetRegion(indexerDeclaration.GetRegion.StartLocation, indexerDeclaration.GetRegion.EndLocation);
                i.CanGet          = true;
                i.GetterModifiers = ConvertModifier(indexerDeclaration.GetRegion.Modifier, ModifierEnum.None);
            }
            if (indexerDeclaration.HasSetRegion)
            {
                i.SetterRegion    = GetRegion(indexerDeclaration.SetRegion.StartLocation, indexerDeclaration.SetRegion.EndLocation);
                i.CanSet          = true;
                i.SetterModifiers = ConvertModifier(indexerDeclaration.SetRegion.Modifier, ModifierEnum.None);
            }
            i.Documentation = GetDocumentation(region.BeginLine, indexerDeclaration.Attributes);
            ConvertAttributes(indexerDeclaration, i);
            if (indexerDeclaration.Parameters != null)
            {
                foreach (AST.ParameterDeclarationExpression par in indexerDeclaration.Parameters)
                {
                    i.Parameters.Add(CreateParameter(par));
                }
            }
            DefaultClass c = GetCurrentClass();

            c.Properties.Add(i);
            return(null);
        }
        public override object VisitIndexerDeclaration(AST.IndexerDeclaration indexerDeclaration, object data)
        {
            DomRegion       region     = GetRegion(indexerDeclaration.StartLocation, indexerDeclaration.EndLocation);
            DomRegion       bodyRegion = GetRegion(indexerDeclaration.BodyStart, indexerDeclaration.BodyEnd);
            DefaultProperty i          = new DefaultProperty("Item", CreateReturnType(indexerDeclaration.TypeReference), ConvertModifier(indexerDeclaration.Modifier), region, bodyRegion, GetCurrentClass());

            i.IsIndexer = true;
            if (indexerDeclaration.HasGetRegion)
            {
                i.GetterRegion    = GetRegion(indexerDeclaration.GetRegion.StartLocation, indexerDeclaration.GetRegion.EndLocation);
                i.CanGet          = true;
                i.GetterModifiers = ConvertModifier(indexerDeclaration.GetRegion.Modifier, ModifierEnum.None);
            }
            if (indexerDeclaration.HasSetRegion)
            {
                i.SetterRegion    = GetRegion(indexerDeclaration.SetRegion.StartLocation, indexerDeclaration.SetRegion.EndLocation);
                i.CanSet          = true;
                i.SetterModifiers = ConvertModifier(indexerDeclaration.SetRegion.Modifier, ModifierEnum.None);
            }
            i.Documentation = GetDocumentation(region.BeginLine, indexerDeclaration.Attributes);
            ConvertAttributes(indexerDeclaration, i);
            if (indexerDeclaration.Parameters != null)
            {
                foreach (AST.ParameterDeclarationExpression par in indexerDeclaration.Parameters)
                {
                    i.Parameters.Add(CreateParameter(par));
                }
            }
            // If an IndexerNameAttribute is specified, use the specified name
            // for the indexer instead of the default name.
            IAttribute indexerNameAttribute = i.Attributes.LastOrDefault(this.IsIndexerNameAttribute);

            if (indexerNameAttribute != null && indexerNameAttribute.PositionalArguments.Count > 0)
            {
                string name = indexerNameAttribute.PositionalArguments[0] as string;
                if (!String.IsNullOrEmpty(name))
                {
                    i.FullyQualifiedName = String.Concat(i.DeclaringType.FullyQualifiedName, ".", name);
                }
            }
            DefaultClass c = GetCurrentClass();

            c.Properties.Add(i);
            return(null);
        }
Example #3
0
	void InterfaceMemberDecl() {

#line  1091 "Frames/cs.ATG" 
		TypeReference type;
			AttributeSection section;
		Modifiers mod = Modifiers.None;
		List<AttributeSection> attributes = new List<AttributeSection>();
		List<ParameterDeclarationExpression> parameters = new List<ParameterDeclarationExpression>();
		string name;
		PropertyGetRegion getBlock;
		PropertySetRegion setBlock;
		Location startLocation = new Location(-1, -1);
		List<TemplateDefinition> templates = new List<TemplateDefinition>();
		
		while (la.kind == 18) {
			AttributeSection(
#line  1104 "Frames/cs.ATG" 
out section);

#line  1104 "Frames/cs.ATG" 
			attributes.Add(section); 
		}
		if (la.kind == 89) {
			lexer.NextToken();

#line  1105 "Frames/cs.ATG" 
			mod = Modifiers.New; startLocation = t.Location; 
		}
		if (
#line  1108 "Frames/cs.ATG" 
NotVoidPointer()) {
			Expect(123);

#line  1108 "Frames/cs.ATG" 
			if (startLocation.IsEmpty) startLocation = t.Location; 
			Identifier();

#line  1109 "Frames/cs.ATG" 
			name = t.val; 
			if (la.kind == 23) {
				TypeParameterList(
#line  1110 "Frames/cs.ATG" 
templates);
			}
			Expect(20);
			if (StartOf(11)) {
				FormalParameterList(
#line  1111 "Frames/cs.ATG" 
parameters);
			}
			Expect(21);
			while (la.kind == 127) {
				TypeParameterConstraintsClause(
#line  1112 "Frames/cs.ATG" 
templates);
			}
			Expect(11);

#line  1114 "Frames/cs.ATG" 
			MethodDeclaration md = new MethodDeclaration {
			Name = name, Modifier = mod, TypeReference = new TypeReference("System.Void", true), 
			Parameters = parameters, Attributes = attributes, Templates = templates,
			StartLocation = startLocation, EndLocation = t.EndLocation
			};
			compilationUnit.AddChild(md);
			
		} else if (StartOf(23)) {
			if (StartOf(10)) {
				Type(
#line  1122 "Frames/cs.ATG" 
out type);

#line  1122 "Frames/cs.ATG" 
				if (startLocation.IsEmpty) startLocation = t.Location; 
				if (StartOf(19)) {
					Identifier();

#line  1124 "Frames/cs.ATG" 
					name = t.val; Location qualIdentEndLocation = t.EndLocation; 
					if (la.kind == 20 || la.kind == 23) {
						if (la.kind == 23) {
							TypeParameterList(
#line  1128 "Frames/cs.ATG" 
templates);
						}
						Expect(20);
						if (StartOf(11)) {
							FormalParameterList(
#line  1129 "Frames/cs.ATG" 
parameters);
						}
						Expect(21);
						while (la.kind == 127) {
							TypeParameterConstraintsClause(
#line  1131 "Frames/cs.ATG" 
templates);
						}
						Expect(11);

#line  1132 "Frames/cs.ATG" 
						MethodDeclaration md = new MethodDeclaration {
						Name = name, Modifier = mod, TypeReference = type,
						Parameters = parameters, Attributes = attributes, Templates = templates,
						StartLocation = startLocation, EndLocation = t.EndLocation
						};
						compilationUnit.AddChild(md);
						
					} else if (la.kind == 16) {

#line  1141 "Frames/cs.ATG" 
						PropertyDeclaration pd = new PropertyDeclaration(name, type, mod, attributes);
						compilationUnit.AddChild(pd); 
						lexer.NextToken();

#line  1144 "Frames/cs.ATG" 
						Location bodyStart = t.Location;
						InterfaceAccessors(
#line  1145 "Frames/cs.ATG" 
out getBlock, out setBlock);
						Expect(17);

#line  1146 "Frames/cs.ATG" 
						pd.GetRegion = getBlock; pd.SetRegion = setBlock; pd.StartLocation = startLocation; pd.EndLocation = qualIdentEndLocation; pd.BodyStart = bodyStart; pd.BodyEnd = t.EndLocation; 
					} else SynErr(175);
				} else if (la.kind == 111) {
					lexer.NextToken();
					Expect(18);
					FormalParameterList(
#line  1149 "Frames/cs.ATG" 
parameters);
					Expect(19);

#line  1150 "Frames/cs.ATG" 
					Location bracketEndLocation = t.EndLocation; 

#line  1151 "Frames/cs.ATG" 
					IndexerDeclaration id = new IndexerDeclaration(type, parameters, mod, attributes);
					compilationUnit.AddChild(id); 
					Expect(16);

#line  1153 "Frames/cs.ATG" 
					Location bodyStart = t.Location;
					InterfaceAccessors(
#line  1154 "Frames/cs.ATG" 
out getBlock, out setBlock);
					Expect(17);

#line  1156 "Frames/cs.ATG" 
					id.GetRegion = getBlock; id.SetRegion = setBlock; id.StartLocation = startLocation;  id.EndLocation = bracketEndLocation; id.BodyStart = bodyStart; id.BodyEnd = t.EndLocation;
				} else SynErr(176);
			} else {
				lexer.NextToken();

#line  1159 "Frames/cs.ATG" 
				if (startLocation.IsEmpty) startLocation = t.Location; 
				Type(
#line  1160 "Frames/cs.ATG" 
out type);
				Identifier();

#line  1161 "Frames/cs.ATG" 
				EventDeclaration ed = new EventDeclaration {
				TypeReference = type, Name = t.val, Modifier = mod, Attributes = attributes
				};
				compilationUnit.AddChild(ed);
				
				Expect(11);

#line  1167 "Frames/cs.ATG" 
				ed.StartLocation = startLocation; ed.EndLocation = t.EndLocation; 
			}
		} else SynErr(177);
	}
Example #4
0
	void StructMemberDecl(
#line  751 "Frames/cs.ATG" 
ModifierList m, List<AttributeSection> attributes) {

#line  753 "Frames/cs.ATG" 
		string qualident = null;
		TypeReference type;
		Expression expr;
		List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>();
		Statement stmt = null;
		List<TemplateDefinition> templates = new List<TemplateDefinition>();
		TypeReference explicitInterface = null;
		bool isExtensionMethod = false;
		
		if (la.kind == 60) {

#line  763 "Frames/cs.ATG" 
			m.Check(Modifiers.Constants); 
			lexer.NextToken();

#line  764 "Frames/cs.ATG" 
			Location startPos = t.Location; 
			Type(
#line  765 "Frames/cs.ATG" 
out type);
			Identifier();

#line  765 "Frames/cs.ATG" 
			FieldDeclaration fd = new FieldDeclaration(attributes, type, m.Modifier | Modifiers.Const);
			fd.StartLocation = m.GetDeclarationLocation(startPos);
			VariableDeclaration f = new VariableDeclaration(t.val);
			f.StartLocation = t.Location;
			f.TypeReference = type;
			SafeAdd(fd, fd.Fields, f);
			
			Expect(3);
			Expr(
#line  772 "Frames/cs.ATG" 
out expr);

#line  772 "Frames/cs.ATG" 
			f.Initializer = expr; 
			while (la.kind == 14) {
				lexer.NextToken();
				Identifier();

#line  773 "Frames/cs.ATG" 
				f = new VariableDeclaration(t.val);
				f.StartLocation = t.Location;
				f.TypeReference = type;
				SafeAdd(fd, fd.Fields, f);
				
				Expect(3);
				Expr(
#line  778 "Frames/cs.ATG" 
out expr);

#line  778 "Frames/cs.ATG" 
				f.EndLocation = t.EndLocation; f.Initializer = expr; 
			}
			Expect(11);

#line  779 "Frames/cs.ATG" 
			fd.EndLocation = t.EndLocation; compilationUnit.AddChild(fd); 
		} else if (
#line  783 "Frames/cs.ATG" 
NotVoidPointer()) {

#line  783 "Frames/cs.ATG" 
			m.Check(Modifiers.PropertysEventsMethods); 
			Expect(123);

#line  784 "Frames/cs.ATG" 
			Location startPos = t.Location; 
			if (
#line  785 "Frames/cs.ATG" 
IsExplicitInterfaceImplementation()) {
				TypeName(
#line  786 "Frames/cs.ATG" 
out explicitInterface, false);

#line  787 "Frames/cs.ATG" 
				if (la.kind != Tokens.Dot || Peek(1).kind != Tokens.This) {
				qualident = TypeReference.StripLastIdentifierFromType(ref explicitInterface);
				 } 
			} else if (StartOf(19)) {
				Identifier();

#line  790 "Frames/cs.ATG" 
				qualident = t.val; 
			} else SynErr(162);
			if (la.kind == 23) {
				TypeParameterList(
#line  793 "Frames/cs.ATG" 
templates);
			}
			Expect(20);
			if (la.kind == 111) {
				lexer.NextToken();

#line  796 "Frames/cs.ATG" 
				isExtensionMethod = true; /* C# 3.0 */ 
			}
			if (StartOf(11)) {
				FormalParameterList(
#line  797 "Frames/cs.ATG" 
p);
			}
			Expect(21);

#line  798 "Frames/cs.ATG" 
			MethodDeclaration methodDeclaration = new MethodDeclaration {
			Name = qualident,
			Modifier = m.Modifier,
			TypeReference = new TypeReference("System.Void", true),
			Parameters = p,
			Attributes = attributes,
			StartLocation = m.GetDeclarationLocation(startPos),
			EndLocation = t.EndLocation,
			Templates = templates,
			IsExtensionMethod = isExtensionMethod
			};
			if (explicitInterface != null)
				SafeAdd(methodDeclaration, methodDeclaration.InterfaceImplementations, new InterfaceImplementation(explicitInterface, qualident));
			compilationUnit.AddChild(methodDeclaration);
			compilationUnit.BlockStart(methodDeclaration);
			
			while (la.kind == 127) {
				TypeParameterConstraintsClause(
#line  816 "Frames/cs.ATG" 
templates);
			}
			if (la.kind == 16) {
				Block(
#line  818 "Frames/cs.ATG" 
out stmt);
			} else if (la.kind == 11) {
				lexer.NextToken();
			} else SynErr(163);

#line  818 "Frames/cs.ATG" 
			compilationUnit.BlockEnd();
			methodDeclaration.Body  = (BlockStatement)stmt;
			
		} else if (la.kind == 69) {

#line  822 "Frames/cs.ATG" 
			m.Check(Modifiers.PropertysEventsMethods); 
			lexer.NextToken();

#line  824 "Frames/cs.ATG" 
			EventDeclaration eventDecl = new EventDeclaration {
			Modifier = m.Modifier, 
			Attributes = attributes,
			StartLocation = t.Location
			};
			compilationUnit.AddChild(eventDecl);
			compilationUnit.BlockStart(eventDecl);
			EventAddRegion addBlock = null;
			EventRemoveRegion removeBlock = null;
			
			Type(
#line  834 "Frames/cs.ATG" 
out type);

#line  834 "Frames/cs.ATG" 
			eventDecl.TypeReference = type; 
			if (
#line  835 "Frames/cs.ATG" 
IsExplicitInterfaceImplementation()) {
				TypeName(
#line  836 "Frames/cs.ATG" 
out explicitInterface, false);

#line  837 "Frames/cs.ATG" 
				qualident = TypeReference.StripLastIdentifierFromType(ref explicitInterface); 

#line  838 "Frames/cs.ATG" 
				eventDecl.InterfaceImplementations.Add(new InterfaceImplementation(explicitInterface, qualident)); 
			} else if (StartOf(19)) {
				Identifier();

#line  840 "Frames/cs.ATG" 
				qualident = t.val; 
			} else SynErr(164);

#line  842 "Frames/cs.ATG" 
			eventDecl.Name = qualident; eventDecl.EndLocation = t.EndLocation; 
			if (la.kind == 3) {
				lexer.NextToken();
				Expr(
#line  843 "Frames/cs.ATG" 
out expr);

#line  843 "Frames/cs.ATG" 
				eventDecl.Initializer = expr; 
			}
			if (la.kind == 16) {
				lexer.NextToken();

#line  844 "Frames/cs.ATG" 
				eventDecl.BodyStart = t.Location; 
				EventAccessorDecls(
#line  845 "Frames/cs.ATG" 
out addBlock, out removeBlock);
				Expect(17);

#line  846 "Frames/cs.ATG" 
				eventDecl.BodyEnd   = t.EndLocation; 
			}

#line  848 "Frames/cs.ATG" 
			compilationUnit.BlockEnd();
			eventDecl.AddRegion = addBlock;
			eventDecl.RemoveRegion = removeBlock;
			
			while (la.kind == 14) {
				lexer.NextToken();
				Identifier();

#line  852 "Frames/cs.ATG" 
				EventDeclaration additionalEventDeclaration = new EventDeclaration {
				    Modifier = eventDecl.Modifier, 
				    Attributes = eventDecl.Attributes,
				    StartLocation = eventDecl.StartLocation,
				    TypeReference = eventDecl.TypeReference,
				    Name = t.val
				};
				compilationUnit.AddChild (additionalEventDeclaration);
				
			}
			if (la.kind == 11) {
				lexer.NextToken();
			}
		} else if (
#line  866 "Frames/cs.ATG" 
IdentAndLPar()) {

#line  866 "Frames/cs.ATG" 
			m.Check(Modifiers.Constructors | Modifiers.StaticConstructors); 
			Identifier();

#line  867 "Frames/cs.ATG" 
			string name = t.val; Location startPos = t.Location; 
			Expect(20);
			if (StartOf(11)) {

#line  867 "Frames/cs.ATG" 
				m.Check(Modifiers.Constructors); 
				FormalParameterList(
#line  868 "Frames/cs.ATG" 
p);
			}
			Expect(21);

#line  870 "Frames/cs.ATG" 
			ConstructorInitializer init = null;  
			if (la.kind == 9) {

#line  871 "Frames/cs.ATG" 
				m.Check(Modifiers.Constructors); 
				ConstructorInitializer(
#line  872 "Frames/cs.ATG" 
out init);
			}

#line  874 "Frames/cs.ATG" 
			ConstructorDeclaration cd = new ConstructorDeclaration(name, m.Modifier, p, init, attributes);
			cd.StartLocation = startPos;
			cd.EndLocation   = t.EndLocation;
			
			if (la.kind == 16) {
				Block(
#line  879 "Frames/cs.ATG" 
out stmt);
			} else if (la.kind == 11) {
				lexer.NextToken();
			} else SynErr(165);

#line  879 "Frames/cs.ATG" 
			cd.Body = (BlockStatement)stmt; compilationUnit.AddChild(cd); 
		} else if (la.kind == 70 || la.kind == 80) {

#line  882 "Frames/cs.ATG" 
			m.Check(Modifiers.Operators);
			if (m.isNone) Error("at least one modifier must be set"); 
			bool isImplicit = true;
			Location startPos = Location.Empty;
			
			if (la.kind == 80) {
				lexer.NextToken();

#line  887 "Frames/cs.ATG" 
				startPos = t.Location; 
			} else {
				lexer.NextToken();

#line  887 "Frames/cs.ATG" 
				isImplicit = false; startPos = t.Location; 
			}
			Expect(92);
			Type(
#line  888 "Frames/cs.ATG" 
out type);

#line  888 "Frames/cs.ATG" 
			TypeReference operatorType = type; 
			Expect(20);
			Type(
#line  889 "Frames/cs.ATG" 
out type);
			Identifier();

#line  889 "Frames/cs.ATG" 
			string varName = t.val; 
			Expect(21);

#line  890 "Frames/cs.ATG" 
			Location endPos = t.Location; 
			if (la.kind == 16) {
				Block(
#line  891 "Frames/cs.ATG" 
out stmt);
			} else if (la.kind == 11) {
				lexer.NextToken();

#line  891 "Frames/cs.ATG" 
				stmt = null; 
			} else SynErr(166);

#line  894 "Frames/cs.ATG" 
			List<ParameterDeclarationExpression> parameters = new List<ParameterDeclarationExpression>();
			parameters.Add(new ParameterDeclarationExpression(type, varName));
			OperatorDeclaration operatorDeclaration = new OperatorDeclaration {
				Name = (isImplicit ? "op_Implicit" : "op_Explicit"),
				Modifier = m.Modifier,
				Attributes = attributes, 
				Parameters = parameters, 
				TypeReference = operatorType,
				ConversionType = isImplicit ? ConversionType.Implicit : ConversionType.Explicit,
				Body = (BlockStatement)stmt,
				StartLocation = m.GetDeclarationLocation(startPos),
				EndLocation = endPos
			};
			compilationUnit.AddChild(operatorDeclaration);
			
		} else if (StartOf(22)) {
			TypeDecl(
#line  912 "Frames/cs.ATG" 
m, attributes);
		} else if (StartOf(10)) {
			Type(
#line  914 "Frames/cs.ATG" 
out type);

#line  914 "Frames/cs.ATG" 
			Location startPos = t.Location;  
			if (la.kind == 92) {

#line  916 "Frames/cs.ATG" 
				OverloadableOperatorType op;
				m.Check(Modifiers.Operators);
				if (m.isNone) Error("at least one modifier must be set");
				
				lexer.NextToken();
				OverloadableOperator(
#line  920 "Frames/cs.ATG" 
out op);

#line  920 "Frames/cs.ATG" 
				TypeReference firstType, secondType = null; string secondName = null; 
				Expect(20);
				Type(
#line  921 "Frames/cs.ATG" 
out firstType);
				Identifier();

#line  921 "Frames/cs.ATG" 
				string firstName = t.val; 
				if (la.kind == 14) {
					lexer.NextToken();
					Type(
#line  922 "Frames/cs.ATG" 
out secondType);
					Identifier();

#line  922 "Frames/cs.ATG" 
					secondName = t.val; 
				} else if (la.kind == 21) {
				} else SynErr(167);

#line  930 "Frames/cs.ATG" 
				Location endPos = t.Location; 
				Expect(21);
				if (la.kind == 16) {
					Block(
#line  931 "Frames/cs.ATG" 
out stmt);
				} else if (la.kind == 11) {
					lexer.NextToken();
				} else SynErr(168);

#line  933 "Frames/cs.ATG" 
				if (op == OverloadableOperatorType.Add && secondType == null)
				op = OverloadableOperatorType.UnaryPlus;
				if (op == OverloadableOperatorType.Subtract && secondType == null)
					op = OverloadableOperatorType.UnaryMinus;
				OperatorDeclaration operatorDeclaration = new OperatorDeclaration {
					Modifier = m.Modifier,
					Attributes = attributes,
					TypeReference = type,
					OverloadableOperator = op,
					Name = GetReflectionNameForOperator(op),
					Body = (BlockStatement)stmt,
					StartLocation = m.GetDeclarationLocation(startPos),
					EndLocation = endPos
				};
				SafeAdd(operatorDeclaration, operatorDeclaration.Parameters, new ParameterDeclarationExpression(firstType, firstName));
				if (secondType != null) {
					SafeAdd(operatorDeclaration, operatorDeclaration.Parameters, new ParameterDeclarationExpression(secondType, secondName));
				}
				compilationUnit.AddChild(operatorDeclaration);
				
			} else if (
#line  955 "Frames/cs.ATG" 
IsVarDecl()) {

#line  956 "Frames/cs.ATG" 
				m.Check(Modifiers.Fields);
				FieldDeclaration fd = new FieldDeclaration(attributes, type, m.Modifier);
				fd.StartLocation = m.GetDeclarationLocation(startPos); 
				
				if (
#line  960 "Frames/cs.ATG" 
m.Contains(Modifiers.Fixed)) {
					VariableDeclarator(
#line  961 "Frames/cs.ATG" 
fd);
					Expect(18);
					Expr(
#line  963 "Frames/cs.ATG" 
out expr);

#line  963 "Frames/cs.ATG" 
					if (fd.Fields.Count > 0)
					fd.Fields[fd.Fields.Count-1].FixedArrayInitialization = expr; 
					Expect(19);
					while (la.kind == 14) {
						lexer.NextToken();
						VariableDeclarator(
#line  967 "Frames/cs.ATG" 
fd);
						Expect(18);
						Expr(
#line  969 "Frames/cs.ATG" 
out expr);

#line  969 "Frames/cs.ATG" 
						if (fd.Fields.Count > 0)
						fd.Fields[fd.Fields.Count-1].FixedArrayInitialization = expr; 
						Expect(19);
					}
				} else if (StartOf(19)) {
					VariableDeclarator(
#line  974 "Frames/cs.ATG" 
fd);
					while (la.kind == 14) {
						lexer.NextToken();
						VariableDeclarator(
#line  975 "Frames/cs.ATG" 
fd);
					}
				} else SynErr(169);
				Expect(11);

#line  977 "Frames/cs.ATG" 
				fd.EndLocation = t.EndLocation; compilationUnit.AddChild(fd); 
			} else if (la.kind == 111) {

#line  980 "Frames/cs.ATG" 
				m.Check(Modifiers.Indexers); 
				lexer.NextToken();
				Expect(18);
				FormalParameterList(
#line  981 "Frames/cs.ATG" 
p);
				Expect(19);

#line  981 "Frames/cs.ATG" 
				Location endLocation = t.EndLocation; 
				Expect(16);

#line  982 "Frames/cs.ATG" 
				IndexerDeclaration indexer = new IndexerDeclaration(type, p, m.Modifier, attributes);
				indexer.StartLocation = startPos;
				indexer.EndLocation   = endLocation;
				indexer.BodyStart     = t.Location;
				PropertyGetRegion getRegion;
				PropertySetRegion setRegion;
				
				AccessorDecls(
#line  989 "Frames/cs.ATG" 
out getRegion, out setRegion);
				Expect(17);

#line  990 "Frames/cs.ATG" 
				indexer.BodyEnd    = t.EndLocation;
				indexer.GetRegion = getRegion;
				indexer.SetRegion = setRegion;
				compilationUnit.AddChild(indexer);
				
			} else if (
#line  995 "Frames/cs.ATG" 
IsIdentifierToken(la)) {
				if (
#line  996 "Frames/cs.ATG" 
IsExplicitInterfaceImplementation()) {
					TypeName(
#line  997 "Frames/cs.ATG" 
out explicitInterface, false);

#line  998 "Frames/cs.ATG" 
					if (la.kind != Tokens.Dot || Peek(1).kind != Tokens.This) {
					qualident = TypeReference.StripLastIdentifierFromType(ref explicitInterface);
					 } 
				} else if (StartOf(19)) {
					Identifier();

#line  1001 "Frames/cs.ATG" 
					qualident = t.val; 
				} else SynErr(170);

#line  1003 "Frames/cs.ATG" 
				Location qualIdentEndLocation = t.EndLocation; 
				if (la.kind == 16 || la.kind == 20 || la.kind == 23) {
					if (la.kind == 20 || la.kind == 23) {

#line  1007 "Frames/cs.ATG" 
						m.Check(Modifiers.PropertysEventsMethods); 
						if (la.kind == 23) {
							TypeParameterList(
#line  1009 "Frames/cs.ATG" 
templates);
						}
						Expect(20);
						if (la.kind == 111) {
							lexer.NextToken();

#line  1011 "Frames/cs.ATG" 
							isExtensionMethod = true; 
						}
						if (StartOf(11)) {
							FormalParameterList(
#line  1012 "Frames/cs.ATG" 
p);
						}
						Expect(21);

#line  1014 "Frames/cs.ATG" 
						MethodDeclaration methodDeclaration = new MethodDeclaration {
						Name = qualident,
						Modifier = m.Modifier,
						TypeReference = type,
						Parameters = p, 
						Attributes = attributes
						};
						if (explicitInterface != null)
							methodDeclaration.InterfaceImplementations.Add(new InterfaceImplementation(explicitInterface, qualident));
						methodDeclaration.StartLocation = m.GetDeclarationLocation(startPos);
						methodDeclaration.EndLocation   = t.EndLocation;
						methodDeclaration.IsExtensionMethod = isExtensionMethod;
						methodDeclaration.Templates = templates;
						compilationUnit.AddChild(methodDeclaration);
						                                      
						while (la.kind == 127) {
							TypeParameterConstraintsClause(
#line  1029 "Frames/cs.ATG" 
templates);
						}
						if (la.kind == 16) {
							Block(
#line  1030 "Frames/cs.ATG" 
out stmt);
						} else if (la.kind == 11) {
							lexer.NextToken();
						} else SynErr(171);

#line  1030 "Frames/cs.ATG" 
						methodDeclaration.Body  = (BlockStatement)stmt; 
					} else {
						lexer.NextToken();

#line  1033 "Frames/cs.ATG" 
						PropertyDeclaration pDecl = new PropertyDeclaration(qualident, type, m.Modifier, attributes); 
						if (explicitInterface != null)
						pDecl.InterfaceImplementations.Add(new InterfaceImplementation(explicitInterface, qualident));
						      pDecl.StartLocation = m.GetDeclarationLocation(startPos);
						      pDecl.EndLocation   = qualIdentEndLocation;
						      pDecl.BodyStart   = t.Location;
						      PropertyGetRegion getRegion;
						      PropertySetRegion setRegion;
						   
						AccessorDecls(
#line  1042 "Frames/cs.ATG" 
out getRegion, out setRegion);
						Expect(17);

#line  1044 "Frames/cs.ATG" 
						pDecl.GetRegion = getRegion;
						pDecl.SetRegion = setRegion;
						pDecl.BodyEnd = t.EndLocation;
						compilationUnit.AddChild(pDecl);
						
					}
				} else if (la.kind == 15) {

#line  1052 "Frames/cs.ATG" 
					m.Check(Modifiers.Indexers); 
					lexer.NextToken();
					Expect(111);
					Expect(18);
					FormalParameterList(
#line  1053 "Frames/cs.ATG" 
p);
					Expect(19);

#line  1054 "Frames/cs.ATG" 
					IndexerDeclaration indexer = new IndexerDeclaration(type, p, m.Modifier, attributes);
					indexer.StartLocation = m.GetDeclarationLocation(startPos);
					indexer.EndLocation   = t.EndLocation;
					if (explicitInterface != null)
					SafeAdd(indexer, indexer.InterfaceImplementations, new InterfaceImplementation(explicitInterface, "this"));
					      PropertyGetRegion getRegion;
					      PropertySetRegion setRegion;
					    
					Expect(16);

#line  1062 "Frames/cs.ATG" 
					Location bodyStart = t.Location; 
					AccessorDecls(
#line  1063 "Frames/cs.ATG" 
out getRegion, out setRegion);
					Expect(17);

#line  1064 "Frames/cs.ATG" 
					indexer.BodyStart = bodyStart;
					indexer.BodyEnd   = t.EndLocation;
					indexer.GetRegion = getRegion;
					indexer.SetRegion = setRegion;
					compilationUnit.AddChild(indexer);
					
				} else SynErr(172);
			} else SynErr(173);
		} else SynErr(174);
	}
Example #5
0
 public virtual object VisitIndexerDeclaration(IndexerDeclaration indexerDeclaration, object data) {
     throw CreateException(indexerDeclaration);
 }
		public virtual object VisitIndexerDeclaration(IndexerDeclaration indexerDeclaration, object data) {
			Debug.Assert((indexerDeclaration != null));
			Debug.Assert((indexerDeclaration.Attributes != null));
			Debug.Assert((indexerDeclaration.Parameters != null));
			Debug.Assert((indexerDeclaration.InterfaceImplementations != null));
			Debug.Assert((indexerDeclaration.TypeReference != null));
			Debug.Assert((indexerDeclaration.GetRegion != null));
			Debug.Assert((indexerDeclaration.SetRegion != null));
			for (int i = 0; i < indexerDeclaration.Attributes.Count; i++) {
				AttributeSection o = indexerDeclaration.Attributes[i];
				Debug.Assert(o != null);
				nodeStack.Push(o);
				o.AcceptVisitor(this, data);
				o = (AttributeSection)nodeStack.Pop();
				if (o == null)
					indexerDeclaration.Attributes.RemoveAt(i--);
				else
					indexerDeclaration.Attributes[i] = o;
			}
			for (int i = 0; i < indexerDeclaration.Parameters.Count; i++) {
				ParameterDeclarationExpression o = indexerDeclaration.Parameters[i];
				Debug.Assert(o != null);
				nodeStack.Push(o);
				o.AcceptVisitor(this, data);
				o = (ParameterDeclarationExpression)nodeStack.Pop();
				if (o == null)
					indexerDeclaration.Parameters.RemoveAt(i--);
				else
					indexerDeclaration.Parameters[i] = o;
			}
			for (int i = 0; i < indexerDeclaration.InterfaceImplementations.Count; i++) {
				InterfaceImplementation o = indexerDeclaration.InterfaceImplementations[i];
				Debug.Assert(o != null);
				nodeStack.Push(o);
				o.AcceptVisitor(this, data);
				o = (InterfaceImplementation)nodeStack.Pop();
				if (o == null)
					indexerDeclaration.InterfaceImplementations.RemoveAt(i--);
				else
					indexerDeclaration.InterfaceImplementations[i] = o;
			}
			nodeStack.Push(indexerDeclaration.TypeReference);
			indexerDeclaration.TypeReference.AcceptVisitor(this, data);
			indexerDeclaration.TypeReference = ((TypeReference)(nodeStack.Pop()));
			nodeStack.Push(indexerDeclaration.GetRegion);
			indexerDeclaration.GetRegion.AcceptVisitor(this, data);
			indexerDeclaration.GetRegion = ((PropertyGetRegion)(nodeStack.Pop()));
			nodeStack.Push(indexerDeclaration.SetRegion);
			indexerDeclaration.SetRegion.AcceptVisitor(this, data);
			indexerDeclaration.SetRegion = ((PropertySetRegion)(nodeStack.Pop()));
			return null;
		}
Example #7
0
	void StructMemberDecl(
#line  727 "cs.ATG" 
ModifierList m, List<AttributeSection> attributes) {

#line  729 "cs.ATG" 
		string qualident = null;
		TypeReference type;
		Expression expr;
		List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>();
		Statement stmt = null;
		List<VariableDeclaration> variableDeclarators = new List<VariableDeclaration>();
		List<TemplateDefinition> templates = new List<TemplateDefinition>();
		TypeReference explicitInterface = null;
		bool isExtensionMethod = false;
		
		if (la.kind == 60) {

#line  740 "cs.ATG" 
			m.Check(Modifiers.Constants); 
			lexer.NextToken();

#line  741 "cs.ATG" 
			Location startPos = t.Location; 
			Type(
#line  742 "cs.ATG" 
out type);
			Identifier();

#line  742 "cs.ATG" 
			FieldDeclaration fd = new FieldDeclaration(attributes, type, m.Modifier | Modifiers.Const);
			fd.StartLocation = m.GetDeclarationLocation(startPos);
			VariableDeclaration f = new VariableDeclaration(t.val);
			fd.Fields.Add(f);
			
			Expect(3);
			Expr(
#line  747 "cs.ATG" 
out expr);

#line  747 "cs.ATG" 
			f.Initializer = expr; 
			while (la.kind == 14) {
				lexer.NextToken();
				Identifier();

#line  748 "cs.ATG" 
				f = new VariableDeclaration(t.val);
				fd.Fields.Add(f);
				
				Expect(3);
				Expr(
#line  751 "cs.ATG" 
out expr);

#line  751 "cs.ATG" 
				f.Initializer = expr; 
			}
			Expect(11);

#line  752 "cs.ATG" 
			fd.EndLocation = t.EndLocation; compilationUnit.AddChild(fd); 
		} else if (
#line  756 "cs.ATG" 
NotVoidPointer()) {

#line  756 "cs.ATG" 
			m.Check(Modifiers.PropertysEventsMethods); 
			Expect(123);

#line  757 "cs.ATG" 
			Location startPos = t.Location; 
			if (
#line  758 "cs.ATG" 
IsExplicitInterfaceImplementation()) {
				TypeName(
#line  759 "cs.ATG" 
out explicitInterface, false);

#line  760 "cs.ATG" 
				if (la.kind != Tokens.Dot || Peek(1).kind != Tokens.This) {
				qualident = TypeReference.StripLastIdentifierFromType(ref explicitInterface);
				 } 
			} else if (StartOf(19)) {
				Identifier();

#line  763 "cs.ATG" 
				qualident = t.val; 
			} else SynErr(162);
			if (la.kind == 23) {
				TypeParameterList(
#line  766 "cs.ATG" 
templates);
			}
			Expect(20);
			if (la.kind == 111) {
				lexer.NextToken();

#line  769 "cs.ATG" 
				isExtensionMethod = true; /* C# 3.0 */ 
			}
			if (StartOf(11)) {
				FormalParameterList(
#line  770 "cs.ATG" 
p);
			}
			Expect(21);

#line  771 "cs.ATG" 
			MethodDeclaration methodDeclaration = new MethodDeclaration {
			Name = qualident,
			Modifier = m.Modifier,
			TypeReference = new TypeReference("void"),
			Parameters = p,
			Attributes = attributes,
			StartLocation = m.GetDeclarationLocation(startPos),
			EndLocation = t.EndLocation,
			Templates = templates,
			IsExtensionMethod = isExtensionMethod
			};
			if (explicitInterface != null)
				methodDeclaration.InterfaceImplementations.Add(new InterfaceImplementation(explicitInterface, qualident));
			compilationUnit.AddChild(methodDeclaration);
			compilationUnit.BlockStart(methodDeclaration);
			
			while (la.kind == 127) {
				TypeParameterConstraintsClause(
#line  789 "cs.ATG" 
templates);
			}
			if (la.kind == 16) {
				Block(
#line  791 "cs.ATG" 
out stmt);
			} else if (la.kind == 11) {
				lexer.NextToken();
			} else SynErr(163);

#line  791 "cs.ATG" 
			compilationUnit.BlockEnd();
			methodDeclaration.Body  = (BlockStatement)stmt;
			
		} else if (la.kind == 69) {

#line  795 "cs.ATG" 
			m.Check(Modifiers.PropertysEventsMethods); 
			lexer.NextToken();

#line  797 "cs.ATG" 
			EventDeclaration eventDecl = new EventDeclaration {
			Modifier = m.Modifier, 
			Attributes = attributes,
			StartLocation = t.Location
			};
			compilationUnit.AddChild(eventDecl);
			compilationUnit.BlockStart(eventDecl);
			EventAddRegion addBlock = null;
			EventRemoveRegion removeBlock = null;
			
			Type(
#line  807 "cs.ATG" 
out type);

#line  807 "cs.ATG" 
			eventDecl.TypeReference = type; 
			if (
#line  808 "cs.ATG" 
IsExplicitInterfaceImplementation()) {
				TypeName(
#line  809 "cs.ATG" 
out explicitInterface, false);

#line  810 "cs.ATG" 
				qualident = TypeReference.StripLastIdentifierFromType(ref explicitInterface); 

#line  811 "cs.ATG" 
				eventDecl.InterfaceImplementations.Add(new InterfaceImplementation(explicitInterface, qualident)); 
			} else if (StartOf(19)) {
				Identifier();

#line  813 "cs.ATG" 
				qualident = t.val; 
			} else SynErr(164);

#line  815 "cs.ATG" 
			eventDecl.Name = qualident; eventDecl.EndLocation = t.EndLocation; 
			if (la.kind == 3) {
				lexer.NextToken();
				Expr(
#line  816 "cs.ATG" 
out expr);

#line  816 "cs.ATG" 
				eventDecl.Initializer = expr; 
			}
			if (la.kind == 16) {
				lexer.NextToken();

#line  817 "cs.ATG" 
				eventDecl.BodyStart = t.Location; 
				EventAccessorDecls(
#line  818 "cs.ATG" 
out addBlock, out removeBlock);
				Expect(17);

#line  819 "cs.ATG" 
				eventDecl.BodyEnd   = t.EndLocation; 
			}
			if (la.kind == 11) {
				lexer.NextToken();
			}

#line  822 "cs.ATG" 
			compilationUnit.BlockEnd();
			eventDecl.AddRegion = addBlock;
			eventDecl.RemoveRegion = removeBlock;
			
		} else if (
#line  828 "cs.ATG" 
IdentAndLPar()) {

#line  828 "cs.ATG" 
			m.Check(Modifiers.Constructors | Modifiers.StaticConstructors); 
			Identifier();

#line  829 "cs.ATG" 
			string name = t.val; Location startPos = t.Location; 
			Expect(20);
			if (StartOf(11)) {

#line  829 "cs.ATG" 
				m.Check(Modifiers.Constructors); 
				FormalParameterList(
#line  830 "cs.ATG" 
p);
			}
			Expect(21);

#line  832 "cs.ATG" 
			ConstructorInitializer init = null;  
			if (la.kind == 9) {

#line  833 "cs.ATG" 
				m.Check(Modifiers.Constructors); 
				ConstructorInitializer(
#line  834 "cs.ATG" 
out init);
			}

#line  836 "cs.ATG" 
			ConstructorDeclaration cd = new ConstructorDeclaration(name, m.Modifier, p, init, attributes); 
			cd.StartLocation = startPos;
			cd.EndLocation   = t.EndLocation;
			
			if (la.kind == 16) {
				Block(
#line  841 "cs.ATG" 
out stmt);
			} else if (la.kind == 11) {
				lexer.NextToken();
			} else SynErr(165);

#line  841 "cs.ATG" 
			cd.Body = (BlockStatement)stmt; compilationUnit.AddChild(cd); 
		} else if (la.kind == 70 || la.kind == 80) {

#line  844 "cs.ATG" 
			m.Check(Modifiers.Operators);
			if (m.isNone) Error("at least one modifier must be set"); 
			bool isImplicit = true;
			Location startPos = Location.Empty;
			
			if (la.kind == 80) {
				lexer.NextToken();

#line  849 "cs.ATG" 
				startPos = t.Location; 
			} else {
				lexer.NextToken();

#line  849 "cs.ATG" 
				isImplicit = false; startPos = t.Location; 
			}
			Expect(92);
			Type(
#line  850 "cs.ATG" 
out type);

#line  850 "cs.ATG" 
			TypeReference operatorType = type; 
			Expect(20);
			Type(
#line  851 "cs.ATG" 
out type);
			Identifier();

#line  851 "cs.ATG" 
			string varName = t.val; 
			Expect(21);

#line  852 "cs.ATG" 
			Location endPos = t.Location; 
			if (la.kind == 16) {
				Block(
#line  853 "cs.ATG" 
out stmt);
			} else if (la.kind == 11) {
				lexer.NextToken();

#line  853 "cs.ATG" 
				stmt = null; 
			} else SynErr(166);

#line  856 "cs.ATG" 
			List<ParameterDeclarationExpression> parameters = new List<ParameterDeclarationExpression>();
			parameters.Add(new ParameterDeclarationExpression(type, varName));
			OperatorDeclaration operatorDeclaration = new OperatorDeclaration {
				Modifier = m.Modifier,
				Attributes = attributes, 
				Parameters = parameters, 
				TypeReference = operatorType,
				ConversionType = isImplicit ? ConversionType.Implicit : ConversionType.Explicit,
				Body = (BlockStatement)stmt,
				StartLocation = m.GetDeclarationLocation(startPos),
				EndLocation = endPos
			};
			compilationUnit.AddChild(operatorDeclaration);
			
		} else if (StartOf(22)) {
			TypeDecl(
#line  873 "cs.ATG" 
m, attributes);
		} else if (StartOf(10)) {
			Type(
#line  875 "cs.ATG" 
out type);

#line  875 "cs.ATG" 
			Location startPos = t.Location;  
			if (la.kind == 92) {

#line  877 "cs.ATG" 
				OverloadableOperatorType op;
				m.Check(Modifiers.Operators);
				if (m.isNone) Error("at least one modifier must be set");
				
				lexer.NextToken();
				OverloadableOperator(
#line  881 "cs.ATG" 
out op);

#line  881 "cs.ATG" 
				TypeReference firstType, secondType = null; string secondName = null; 
				Expect(20);
				Type(
#line  882 "cs.ATG" 
out firstType);
				Identifier();

#line  882 "cs.ATG" 
				string firstName = t.val; 
				if (la.kind == 14) {
					lexer.NextToken();
					Type(
#line  883 "cs.ATG" 
out secondType);
					Identifier();

#line  883 "cs.ATG" 
					secondName = t.val; 
				} else if (la.kind == 21) {
				} else SynErr(167);

#line  891 "cs.ATG" 
				Location endPos = t.Location; 
				Expect(21);
				if (la.kind == 16) {
					Block(
#line  892 "cs.ATG" 
out stmt);
				} else if (la.kind == 11) {
					lexer.NextToken();
				} else SynErr(168);

#line  894 "cs.ATG" 
				List<ParameterDeclarationExpression> parameters = new List<ParameterDeclarationExpression>();
				parameters.Add(new ParameterDeclarationExpression(firstType, firstName));
				if (secondType != null) {
					parameters.Add(new ParameterDeclarationExpression(secondType, secondName));
				}
				OperatorDeclaration operatorDeclaration = new OperatorDeclaration {
					Modifier = m.Modifier,
					Attributes = attributes,
					Parameters = parameters,
					TypeReference = type,
					OverloadableOperator = op,
					Body = (BlockStatement)stmt,
					StartLocation = m.GetDeclarationLocation(startPos),
					EndLocation = endPos
				};
				compilationUnit.AddChild(operatorDeclaration);
				
			} else if (
#line  913 "cs.ATG" 
IsVarDecl()) {

#line  914 "cs.ATG" 
				m.Check(Modifiers.Fields);
				FieldDeclaration fd = new FieldDeclaration(attributes, type, m.Modifier);
				fd.StartLocation = m.GetDeclarationLocation(startPos); 
				
				if (
#line  918 "cs.ATG" 
m.Contains(Modifiers.Fixed)) {
					VariableDeclarator(
#line  919 "cs.ATG" 
variableDeclarators);
					Expect(18);
					Expr(
#line  921 "cs.ATG" 
out expr);

#line  921 "cs.ATG" 
					if (variableDeclarators.Count > 0)
					variableDeclarators[variableDeclarators.Count-1].FixedArrayInitialization = expr; 
					Expect(19);
					while (la.kind == 14) {
						lexer.NextToken();
						VariableDeclarator(
#line  925 "cs.ATG" 
variableDeclarators);
						Expect(18);
						Expr(
#line  927 "cs.ATG" 
out expr);

#line  927 "cs.ATG" 
						if (variableDeclarators.Count > 0)
						variableDeclarators[variableDeclarators.Count-1].FixedArrayInitialization = expr; 
						Expect(19);
					}
				} else if (StartOf(19)) {
					VariableDeclarator(
#line  932 "cs.ATG" 
variableDeclarators);
					while (la.kind == 14) {
						lexer.NextToken();
						VariableDeclarator(
#line  933 "cs.ATG" 
variableDeclarators);
					}
				} else SynErr(169);
				Expect(11);

#line  935 "cs.ATG" 
				fd.EndLocation = t.EndLocation; fd.Fields = variableDeclarators; compilationUnit.AddChild(fd); 
			} else if (la.kind == 111) {

#line  938 "cs.ATG" 
				m.Check(Modifiers.Indexers); 
				lexer.NextToken();
				Expect(18);
				FormalParameterList(
#line  939 "cs.ATG" 
p);
				Expect(19);

#line  939 "cs.ATG" 
				Location endLocation = t.EndLocation; 
				Expect(16);

#line  940 "cs.ATG" 
				IndexerDeclaration indexer = new IndexerDeclaration(type, p, m.Modifier, attributes);
				indexer.StartLocation = startPos;
				indexer.EndLocation   = endLocation;
				indexer.BodyStart     = t.Location;
				PropertyGetRegion getRegion;
				PropertySetRegion setRegion;
				
				AccessorDecls(
#line  947 "cs.ATG" 
out getRegion, out setRegion);
				Expect(17);

#line  948 "cs.ATG" 
				indexer.BodyEnd    = t.EndLocation;
				indexer.GetRegion = getRegion;
				indexer.SetRegion = setRegion;
				compilationUnit.AddChild(indexer);
				
			} else if (
#line  953 "cs.ATG" 
IsIdentifierToken(la)) {
				if (
#line  954 "cs.ATG" 
IsExplicitInterfaceImplementation()) {
					TypeName(
#line  955 "cs.ATG" 
out explicitInterface, false);

#line  956 "cs.ATG" 
					if (la.kind != Tokens.Dot || Peek(1).kind != Tokens.This) {
					qualident = TypeReference.StripLastIdentifierFromType(ref explicitInterface);
					 } 
				} else if (StartOf(19)) {
					Identifier();

#line  959 "cs.ATG" 
					qualident = t.val; 
				} else SynErr(170);

#line  961 "cs.ATG" 
				Location qualIdentEndLocation = t.EndLocation; 
				if (la.kind == 16 || la.kind == 20 || la.kind == 23) {
					if (la.kind == 20 || la.kind == 23) {

#line  965 "cs.ATG" 
						m.Check(Modifiers.PropertysEventsMethods); 
						if (la.kind == 23) {
							TypeParameterList(
#line  967 "cs.ATG" 
templates);
						}
						Expect(20);
						if (la.kind == 111) {
							lexer.NextToken();

#line  969 "cs.ATG" 
							isExtensionMethod = true; 
						}
						if (StartOf(11)) {
							FormalParameterList(
#line  970 "cs.ATG" 
p);
						}
						Expect(21);

#line  972 "cs.ATG" 
						MethodDeclaration methodDeclaration = new MethodDeclaration {
						Name = qualident,
						Modifier = m.Modifier,
						TypeReference = type,
						Parameters = p, 
						Attributes = attributes
						};
						if (explicitInterface != null)
							methodDeclaration.InterfaceImplementations.Add(new InterfaceImplementation(explicitInterface, qualident));
						methodDeclaration.StartLocation = m.GetDeclarationLocation(startPos);
						methodDeclaration.EndLocation   = t.EndLocation;
						methodDeclaration.IsExtensionMethod = isExtensionMethod;
						methodDeclaration.Templates = templates;
						compilationUnit.AddChild(methodDeclaration);
						                                      
						while (la.kind == 127) {
							TypeParameterConstraintsClause(
#line  987 "cs.ATG" 
templates);
						}
						if (la.kind == 16) {
							Block(
#line  988 "cs.ATG" 
out stmt);
						} else if (la.kind == 11) {
							lexer.NextToken();
						} else SynErr(171);

#line  988 "cs.ATG" 
						methodDeclaration.Body  = (BlockStatement)stmt; 
					} else {
						lexer.NextToken();

#line  991 "cs.ATG" 
						PropertyDeclaration pDecl = new PropertyDeclaration(qualident, type, m.Modifier, attributes); 
						if (explicitInterface != null)
						pDecl.InterfaceImplementations.Add(new InterfaceImplementation(explicitInterface, qualident));
						      pDecl.StartLocation = m.GetDeclarationLocation(startPos);
						      pDecl.EndLocation   = qualIdentEndLocation;
						      pDecl.BodyStart   = t.Location;
						      PropertyGetRegion getRegion;
						      PropertySetRegion setRegion;
						   
						AccessorDecls(
#line  1000 "cs.ATG" 
out getRegion, out setRegion);
						Expect(17);

#line  1002 "cs.ATG" 
						pDecl.GetRegion = getRegion;
						pDecl.SetRegion = setRegion;
						pDecl.BodyEnd = t.EndLocation;
						compilationUnit.AddChild(pDecl);
						
					}
				} else if (la.kind == 15) {

#line  1010 "cs.ATG" 
					m.Check(Modifiers.Indexers); 
					lexer.NextToken();
					Expect(111);
					Expect(18);
					FormalParameterList(
#line  1011 "cs.ATG" 
p);
					Expect(19);

#line  1012 "cs.ATG" 
					IndexerDeclaration indexer = new IndexerDeclaration(type, p, m.Modifier, attributes);
					indexer.StartLocation = m.GetDeclarationLocation(startPos);
					indexer.EndLocation   = t.EndLocation;
					if (explicitInterface != null)
					indexer.InterfaceImplementations.Add(new InterfaceImplementation(explicitInterface, "this"));
					      PropertyGetRegion getRegion;
					      PropertySetRegion setRegion;
					    
					Expect(16);

#line  1020 "cs.ATG" 
					Location bodyStart = t.Location; 
					AccessorDecls(
#line  1021 "cs.ATG" 
out getRegion, out setRegion);
					Expect(17);

#line  1022 "cs.ATG" 
					indexer.BodyStart = bodyStart;
					indexer.BodyEnd   = t.EndLocation;
					indexer.GetRegion = getRegion;
					indexer.SetRegion = setRegion;
					compilationUnit.AddChild(indexer);
					
				} else SynErr(172);
			} else SynErr(173);
		} else SynErr(174);
	}
		public sealed override object VisitIndexerDeclaration(IndexerDeclaration indexerDeclaration, object data) {
			this.BeginVisit(indexerDeclaration);
			object result = this.TrackedVisitIndexerDeclaration(indexerDeclaration, data);
			this.EndVisit(indexerDeclaration);
			return result;
		}
 public virtual bool VisitIndexerDeclaration(IndexerDeclaration indexerDeclaration, object d)
 {
     if ((indexerDeclaration == null)) {
         return SetFailure();
     }
     if ((d == null)) {
         return SetFailure();
     }
     if ((indexerDeclaration.Attributes == null)) {
         return SetFailure();
     }
     if ((indexerDeclaration.Parameters == null)) {
         return SetFailure();
     }
     if ((indexerDeclaration.InterfaceImplementations == null)) {
         return SetFailure();
     }
     if ((indexerDeclaration.TypeReference == null)) {
         return SetFailure();
     }
     if ((indexerDeclaration.GetRegion == null)) {
         return SetFailure();
     }
     if ((indexerDeclaration.SetRegion == null)) {
         return SetFailure();
     }
     if(indexerDeclaration.GetType() != d.GetType()) {return SetFailure();}
     var data = (IndexerDeclaration)d;
     if (!IsMatch(indexerDeclaration, data)) {
         return SetFailure();
     }
     if (indexerDeclaration.Attributes.Count == data.Attributes.Count) {
     for (int i=0; i<indexerDeclaration.Attributes.Count;i++) {
         AttributeSection o = indexerDeclaration.Attributes[i];
         if(o == null){return SetFailure();}
         if((bool)o.AcceptVisitor(this, data.Attributes[i]) == false) return SetFailure();
     }			}			else { return SetFailure(); }
     if (indexerDeclaration.Parameters.Count == data.Parameters.Count) {
     for (int i=0; i<indexerDeclaration.Parameters.Count;i++) {
         ParameterDeclarationExpression o = indexerDeclaration.Parameters[i];
         if(o == null){return SetFailure();}
         if((bool)o.AcceptVisitor(this, data.Parameters[i]) == false) return SetFailure();
     }			}			else { return SetFailure(); }
     if (indexerDeclaration.InterfaceImplementations.Count == data.InterfaceImplementations.Count) {
     for (int i=0; i<indexerDeclaration.InterfaceImplementations.Count;i++) {
         InterfaceImplementation o = indexerDeclaration.InterfaceImplementations[i];
         if(o == null){return SetFailure();}
         if((bool)o.AcceptVisitor(this, data.InterfaceImplementations[i]) == false) return SetFailure();
     }			}			else { return SetFailure(); }
     indexerDeclaration.TypeReference.AcceptVisitor(this, data.TypeReference);
     indexerDeclaration.GetRegion.AcceptVisitor(this, data.GetRegion);
     return indexerDeclaration.SetRegion.AcceptVisitor(this, data.SetRegion);
 }
 private bool IsMatch(IndexerDeclaration left, IndexerDeclaration data)
 {
     return true;
 }
Example #11
0
 public override object VisitIndexerDeclaration(IndexerDeclaration indexerDeclaration, object data)
 {
     indexerDeclaration.GetRegion.Parent = indexerDeclaration;
     indexerDeclaration.SetRegion.Parent = indexerDeclaration;
     indexerDeclaration.TypeReference.Parent = indexerDeclaration;
     foreach (ParameterDeclarationExpression parameter in indexerDeclaration.Parameters)
         parameter.Parent = indexerDeclaration;
     return base.VisitIndexerDeclaration(indexerDeclaration, data);
 }
Example #12
0
 public override object VisitIndexerDeclaration (IndexerDeclaration node, object data)
 {
     if (node.HasGetRegion) {
         Write ("get: function(");
         Write (node.Parameters[0].ParameterName);
         Write (")");
         PushLocals ();
         Locals.Add (node.Parameters[0].ParameterName, node.Parameters[0].TypeReference);
         node.GetRegion.Block.AcceptVisitor (this, null);
         PopLocals ();
         
         if (node.HasSetRegion) {
             WriteComma ();
             NewLine ();
             NewLine ();
         }
     }
     
     if (node.HasSetRegion) {
         Write ("set: function(");
         Write (node.Parameters[0].ParameterName);
         Write (", value)");
         PushLocals ();
         Locals.Add (node.Parameters[0].ParameterName, node.Parameters[0].TypeReference);
         Locals.Add ("value", node.TypeReference);
         node.SetRegion.Block.AcceptVisitor (this, null);
         PopLocals ();
     }
     
     return node.TypeReference;
 }
		public override object VisitIndexerDeclaration(IndexerDeclaration indexerDeclaration, object data)
		{
			if (this.CheckNode(indexerDeclaration)) {
				return null;
			}
			return base.VisitIndexerDeclaration(indexerDeclaration, data);
		}
Example #14
0
 public override object VisitIndexerDeclaration (IndexerDeclaration node, object data)
 {
     
     bool isStatic = CurrentType.ClassType == ClassType.Enum || HasModifier (node.Modifier, Modifiers.Static) || HasModifier (node.Modifier, Modifiers.Const);
     
     if (isStatic) {
         CurrentType.StaticIndexers.Add (node.TypeReference, node);
     } else {
         CurrentType.InstanceIndexers.Add(node.TypeReference, node);
     }
     return null;
 }
		public object VisitIndexerDeclaration(IndexerDeclaration indexerDeclaration, object data)
		{
			B.Property m = new B.Property(GetLexicalInfo(indexerDeclaration));
			
			m.Modifiers = ConvertModifier(indexerDeclaration, B.TypeMemberModifiers.Private);
			ConvertAttributes(indexerDeclaration.Attributes, m.Attributes);
			if (currentType != null) currentType.Members.Add(m);
			ConvertParameters(indexerDeclaration.Parameters, m.Parameters);
			m.EndSourceLocation = GetLocation(indexerDeclaration.EndLocation);
			m.Type = ConvertTypeReference(indexerDeclaration.TypeReference);
			m.Name = "this";
			m.ExplicitInfo = ConvertInterfaceImplementations(indexerDeclaration.InterfaceImplementations, indexerDeclaration, m);
			m.Name = "self";
			if (!indexerDeclaration.IsWriteOnly) {
				m.Getter = new B.Method(GetLexicalInfo(indexerDeclaration.GetRegion));
				if (indexerDeclaration.GetRegion != null) {
					ConvertAttributes(indexerDeclaration.GetRegion.Attributes, m.Getter.Attributes);
					m.Modifiers = ConvertModifier(indexerDeclaration.GetRegion, m.Visibility);
					m.Getter.Body = ConvertMethodBlock(indexerDeclaration.GetRegion.Block);
					m.Getter.ReturnType = m.Type;
				}
			}
			if (!indexerDeclaration.IsReadOnly) {
				m.Setter = new B.Method(GetLexicalInfo(indexerDeclaration.SetRegion));
				if (indexerDeclaration.SetRegion != null) {
					ConvertAttributes(indexerDeclaration.SetRegion.Attributes, m.Setter.Attributes);
					m.Modifiers = ConvertModifier(indexerDeclaration.SetRegion, m.Visibility);
					m.Setter.Body = ConvertMethodBlock(indexerDeclaration.SetRegion.Block);
				}
			}
			return m;
		}
 public virtual object VisitIndexerDeclaration(IndexerDeclaration indexerDeclaration, object data)
 {
     throw new global::System.NotImplementedException("IndexerDeclaration");
 }
 public object VisitIndexerDeclaration(IndexerDeclaration indexerDeclaration, object data)
 {
     throw new NotImplementedException ();
 }
		public virtual object TrackedVisitIndexerDeclaration(IndexerDeclaration indexerDeclaration, object data) {
			return base.VisitIndexerDeclaration(indexerDeclaration, data);
		}
Example #19
0
 public virtual object VisitIndexerDeclaration(IndexerDeclaration indexerDeclaration, object data)
 {
     Debug.Assert((indexerDeclaration != null));
     Debug.Assert((indexerDeclaration.Attributes != null));
     Debug.Assert((indexerDeclaration.Parameters != null));
     Debug.Assert((indexerDeclaration.InterfaceImplementations != null));
     Debug.Assert((indexerDeclaration.TypeReference != null));
     Debug.Assert((indexerDeclaration.GetRegion != null));
     Debug.Assert((indexerDeclaration.SetRegion != null));
     foreach (AttributeSection o in indexerDeclaration.Attributes) {
         Debug.Assert(o != null);
         o.AcceptVisitor(this, data);
     }
     foreach (ParameterDeclarationExpression o in indexerDeclaration.Parameters) {
         Debug.Assert(o != null);
         o.AcceptVisitor(this, data);
     }
     foreach (InterfaceImplementation o in indexerDeclaration.InterfaceImplementations) {
         Debug.Assert(o != null);
         o.AcceptVisitor(this, data);
     }
     indexerDeclaration.TypeReference.AcceptVisitor(this, data);
     indexerDeclaration.GetRegion.AcceptVisitor(this, data);
     return indexerDeclaration.SetRegion.AcceptVisitor(this, data);
 }
 public override object TrackedVisitIndexerDeclaration(IndexerDeclaration indexerDeclaration, object data)
 {
     Console.WriteLine("VisitIndexerDeclaration");
     return null;
 }
		public override object VisitIndexerDeclaration(IndexerDeclaration indexerDeclaration, object data)
		{
			return base.VisitIndexerDeclaration(indexerDeclaration, data);
		}