redef fun replace_child(old_child: ANode, new_child: nullable ANode) do end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_moduledecl == old_child then
			n_moduledecl = new_child.as(nullable AModuledecl)
			return
		end
		if n_imports.replace_child(old_child, new_child) then return
		if n_extern_code_blocks.replace_child(old_child, new_child) then return
		if n_classdefs.replace_child(old_child, new_child) then return
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_id == old_child then
			n_id = new_child.as(TClassid)
			return
		end
		if _n_type == old_child then
			n_type = new_child.as(nullable AType)
			return
		end
		if _n_annotations == old_child then
			n_annotations = new_child.as(nullable AAnnotations)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_qualified == old_child then
			n_qualified = new_child.as(nullable AQualified)
			return
		end
		if _n_id == old_child then
			n_id = new_child.as(TId)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_qualified == old_child then
			n_qualified = new_child.as(nullable AQualified)
			return
		end
		if _n_id == old_child then
			n_id = new_child.as(TClassid)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_opar == old_child then
			n_opar = new_child.as(nullable TOpar)
			return
		end
		if n_params.replace_child(old_child, new_child) then return
		if _n_cpar == old_child then
			n_cpar = new_child.as(nullable TCpar)
			return
		end
		if _n_type == old_child then
			n_type = new_child.as(nullable AType)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_id == old_child then
			n_id = new_child.as(TId)
			return
		end
		if _n_type == old_child then
			n_type = new_child.as(nullable AType)
			return
		end
		if _n_dotdotdot == old_child then
			n_dotdotdot = new_child.as(nullable TDotdotdot)
			return
		end
		if _n_annotations == old_child then
			n_annotations = new_child.as(nullable AAnnotations)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_kwnullable == old_child then
			n_kwnullable = new_child.as(nullable TKwnullable)
			return
		end
		if _n_qid == old_child then
			n_qid = new_child.as(AQclassid)
			return
		end
		if _n_obra == old_child then
			n_obra = new_child.as(nullable TObra)
			return
		end
		if n_types.replace_child(old_child, new_child) then return
		if _n_cbra == old_child then
			n_cbra = new_child.as(nullable TCbra)
			return
		end
		if _n_annotations == old_child then
			n_annotations = new_child.as(nullable AAnnotations)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_kwlabel == old_child then
			n_kwlabel = new_child.as(TKwlabel)
			return
		end
		if _n_id == old_child then
			n_id = new_child.as(nullable TId)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if n_ids.replace_child(old_child, new_child) then return
		if _n_kwin == old_child then
			n_kwin = new_child.as(TKwin)
			return
		end
		if _n_expr == old_child then
			n_expr = new_child.as(AExpr)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_quad == old_child then
			n_quad = new_child.as(nullable TQuad)
			return
		end
		if n_path.replace_child(old_child, new_child) then return
		if _n_id == old_child then
			n_id = new_child.as(TId)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_kwimport == old_child then
			n_kwimport = new_child.as(TKwimport)
			return
		end
		if n_extern_calls.replace_child(old_child, new_child) then return
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_kwin == old_child then
			n_kwin = new_child.as(TKwin)
			return
		end
		if _n_string == old_child then
			n_string = new_child.as(TString)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_in_language == old_child then
			n_in_language = new_child.as(nullable AInLanguage)
			return
		end
		if _n_extern_code_segment == old_child then
			n_extern_code_segment = new_child.as(TExternCodeSegment)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if n_id.replace_child(old_child, new_child) then return
		if _n_classid == old_child then
			n_classid = new_child.as(nullable TClassid)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if n_comment.replace_child(old_child, new_child) then return
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_kwis == old_child then
			n_kwis = new_child.as(nullable TKwis)
			return
		end
		if _n_at == old_child then
			n_at = new_child.as(nullable TAt)
			return
		end
		if _n_opar == old_child then
			n_opar = new_child.as(nullable TOpar)
			return
		end
		if n_items.replace_child(old_child, new_child) then return
		if _n_cpar == old_child then
			n_cpar = new_child.as(nullable TCpar)
			return
		end
		if _n_kwend == old_child then
			n_kwend = new_child.as(nullable TKwend)
			return
		end
	end

    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
    do
        if _n_base == old_child then
            if new_child == null then
            else
                new_child.parent = self
		assert new_child isa AModule
                _n_base = new_child
            end
            old_child.parent = null
            return
	end
    end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if n_expr.replace_child(old_child, new_child) then return
		if _n_kwend == old_child then
			n_kwend = new_child.as(nullable TKwend)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_kwvar == old_child then
			n_kwvar = new_child.as(nullable TKwvar)
			return
		end
		if _n_id == old_child then
			n_id = new_child.as(TId)
			return
		end
		if _n_type == old_child then
			n_type = new_child.as(nullable AType)
			return
		end
		if _n_assign == old_child then
			n_assign = new_child.as(nullable TAssign)
			return
		end
		if _n_expr == old_child then
			n_expr = new_child.as(nullable AExpr)
			return
		end
		if _n_annotations == old_child then
			n_annotations = new_child.as(nullable AAnnotations)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_kwself == old_child then
			n_kwself = new_child.as(TKwself)
			return
		end
		if _n_annotations == old_child then
			n_annotations = new_child.as(nullable AAnnotations)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_kwabort == old_child then
			n_kwabort = new_child.as(TKwabort)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_kwif == old_child then
			n_kwif = new_child.as(TKwif)
			return
		end
		if _n_expr == old_child then
			n_expr = new_child.as(AExpr)
			return
		end
		if _n_kwthen == old_child then
			n_kwthen = new_child.as(TKwthen)
			return
		end
		if _n_then == old_child then
			n_then = new_child.as(nullable AExpr)
			return
		end
		if _n_kwelse == old_child then
			n_kwelse = new_child.as(nullable TKwelse)
			return
		end
		if _n_else == old_child then
			n_else = new_child.as(nullable AExpr)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_kwif == old_child then
			n_kwif = new_child.as(TKwif)
			return
		end
		if _n_expr == old_child then
			n_expr = new_child.as(AExpr)
			return
		end
		if _n_kwthen == old_child then
			n_kwthen = new_child.as(TKwthen)
			return
		end
		if _n_then == old_child then
			n_then = new_child.as(AExpr)
			return
		end
		if _n_kwelse == old_child then
			n_kwelse = new_child.as(TKwelse)
			return
		end
		if _n_else == old_child then
			n_else = new_child.as(AExpr)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_kwassert == old_child then
			n_kwassert = new_child.as(TKwassert)
			return
		end
		if _n_id == old_child then
			n_id = new_child.as(nullable TId)
			return
		end
		if _n_expr == old_child then
			n_expr = new_child.as(AExpr)
			return
		end
		if _n_kwelse == old_child then
			n_kwelse = new_child.as(nullable TKwelse)
			return
		end
		if _n_else == old_child then
			n_else = new_child.as(nullable AExpr)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_integer == old_child then
			n_integer = new_child.as(TInteger)
			return
		end
		if _n_annotations == old_child then
			n_annotations = new_child.as(nullable AAnnotations)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_float == old_child then
			n_float = new_child.as(TFloat)
			return
		end
		if _n_annotations == old_child then
			n_annotations = new_child.as(nullable AAnnotations)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_obra == old_child then
			n_obra = new_child.as(TObra)
			return
		end
		if n_exprs.replace_child(old_child, new_child) then return
		if _n_type == old_child then
			n_type = new_child.as(nullable AType)
			return
		end
		if _n_cbra == old_child then
			n_cbra = new_child.as(TCbra)
			return
		end
		if _n_annotations == old_child then
			n_annotations = new_child.as(nullable AAnnotations)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_kwnull == old_child then
			n_kwnull = new_child.as(TKwnull)
			return
		end
		if _n_annotations == old_child then
			n_annotations = new_child.as(nullable AAnnotations)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_opar == old_child then
			n_opar = new_child.as(TOpar)
			return
		end
		if _n_expr == old_child then
			n_expr = new_child.as(AExpr)
			return
		end
		if _n_cpar == old_child then
			n_cpar = new_child.as(TCpar)
			return
		end
		if _n_annotations == old_child then
			n_annotations = new_child.as(nullable AAnnotations)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_kwonce == old_child then
			n_kwonce = new_child.as(TKwonce)
			return
		end
		if _n_expr == old_child then
			n_expr = new_child.as(AExpr)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_expr == old_child then
			n_expr = new_child.as(AExpr)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_qualified == old_child then
			n_qualified = new_child.as(nullable AQualified)
			return
		end
		if _n_kwsuper == old_child then
			n_kwsuper = new_child.as(TKwsuper)
			return
		end
		if _n_args == old_child then
			n_args = new_child.as(AExprs)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_kwnew == old_child then
			n_kwnew = new_child.as(TKwnew)
			return
		end
		if _n_type == old_child then
			n_type = new_child.as(AType)
			return
		end
		if _n_qid == old_child then
			n_qid = new_child.as(nullable AQid)
			return
		end
		if _n_args == old_child then
			n_args = new_child.as(AExprs)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_expr == old_child then
			n_expr = new_child.as(AExpr)
			return
		end
		if _n_dotdotdot == old_child then
			n_dotdotdot = new_child.as(TDotdotdot)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_expr == old_child then
			n_expr = new_child.as(AExpr)
			return
		end
		if _n_quest == old_child then
			n_quest = new_child.as(TQuest)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_id == old_child then
			n_id = new_child.as(TId)
			return
		end
		if _n_assign == old_child then
			n_assign = new_child.as(TAssign)
			return
		end
		if _n_expr == old_child then
			n_expr = new_child.as(AExpr)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_kwdebug == old_child then
			n_kwdebug = new_child.as(TKwdebug)
			return
		end
		if _n_kwtype == old_child then
			n_kwtype = new_child.as(TKwtype)
			return
		end
		if _n_expr == old_child then
			n_expr = new_child.as(AExpr)
			return
		end
		if _n_type == old_child then
			n_type = new_child.as(AType)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_doc == old_child then
			n_doc = new_child.as(nullable ADoc)
			return
		end
		if _n_kwredef == old_child then
			n_kwredef = new_child.as(nullable TKwredef)
			return
		end
		if _n_visibility == old_child then
			n_visibility = new_child.as(AVisibility)
			return
		end
		if _n_kwmodule == old_child then
			n_kwmodule = new_child.as(TKwmodule)
			return
		end
		if _n_name == old_child then
			n_name = new_child.as(AModuleName)
			return
		end
		if _n_annotations == old_child then
			n_annotations = new_child.as(nullable AAnnotations)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_visibility == old_child then
			n_visibility = new_child.as(AVisibility)
			return
		end
		if _n_kwimport == old_child then
			n_kwimport = new_child.as(TKwimport)
			return
		end
		if _n_name == old_child then
			n_name = new_child.as(AModuleName)
			return
		end
		if _n_annotations == old_child then
			n_annotations = new_child.as(nullable AAnnotations)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_visibility == old_child then
			n_visibility = new_child.as(AVisibility)
			return
		end
		if _n_kwimport == old_child then
			n_kwimport = new_child.as(TKwimport)
			return
		end
		if _n_kwend == old_child then
			n_kwend = new_child.as(TKwend)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_kwpublic == old_child then
			n_kwpublic = new_child.as(nullable TKwpublic)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_kwprivate == old_child then
			n_kwprivate = new_child.as(TKwprivate)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_kwprotected == old_child then
			n_kwprotected = new_child.as(TKwprotected)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_kwintrude == old_child then
			n_kwintrude = new_child.as(TKwintrude)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if n_propdefs.replace_child(old_child, new_child) then return
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if n_propdefs.replace_child(old_child, new_child) then return
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_kwclass == old_child then
			n_kwclass = new_child.as(TKwclass)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_kwabstract == old_child then
			n_kwabstract = new_child.as(TKwabstract)
			return
		end
		if _n_kwclass == old_child then
			n_kwclass = new_child.as(TKwclass)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_kwinterface == old_child then
			n_kwinterface = new_child.as(TKwinterface)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_kwenum == old_child then
			n_kwenum = new_child.as(TKwenum)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_kwextern == old_child then
			n_kwextern = new_child.as(TKwextern)
			return
		end
		if _n_kwclass == old_child then
			n_kwclass = new_child.as(nullable TKwclass)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_kwsubset == old_child then
			n_kwsubset = new_child.as(TKwsubset)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_id == old_child then
			n_id = new_child.as(TId)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_obra == old_child then
			n_obra = new_child.as(TObra)
			return
		end
		if _n_cbra == old_child then
			n_cbra = new_child.as(TCbra)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_id == old_child then
			n_id = new_child.as(TId)
			return
		end
		if _n_assign == old_child then
			n_assign = new_child.as(TAssign)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_obra == old_child then
			n_obra = new_child.as(TObra)
			return
		end
		if _n_cbra == old_child then
			n_cbra = new_child.as(TCbra)
			return
		end
		if _n_assign == old_child then
			n_assign = new_child.as(TAssign)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_kwyield == old_child then
			n_kwyield = new_child.as(TKwyield)
			return
		end
		if _n_expr == old_child then
			n_expr = new_child.as(AExpr)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_expr == old_child then
			n_expr = new_child.as(AExpr)
			return
		end
		if _n_expr2 == old_child then
			n_expr2 = new_child.as(AExpr)
			return
		end
		if _n_annotations == old_child then
			n_annotations = new_child.as(nullable AAnnotations)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_kwmeth == old_child then
			n_kwmeth = new_child.as(TKwmeth)
			return
		end
		if _n_signature == old_child then
			n_signature = new_child.as(ASignature)
			return
		end
		if _n_kwdo == old_child then
			n_kwdo = new_child.as(TKwdo)
			return
		end
		if _n_expr == old_child then
			n_expr = new_child.as(AExpr)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_type == old_child then
			n_type = new_child.as(AType)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_expr == old_child then
			n_expr = new_child.as(AExpr)
			return
		end
		if _n_id == old_child then
			n_id = new_child.as(AMethid)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_annotations == old_child then
			n_annotations = new_child.as(AAnnotations)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if n_exprs.replace_child(old_child, new_child) then return
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if n_exprs.replace_child(old_child, new_child) then return
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_opar == old_child then
			n_opar = new_child.as(TOpar)
			return
		end
		if n_exprs.replace_child(old_child, new_child) then return
		if _n_cpar == old_child then
			n_cpar = new_child.as(TCpar)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_obra == old_child then
			n_obra = new_child.as(TObra)
			return
		end
		if n_exprs.replace_child(old_child, new_child) then return
		if _n_cbra == old_child then
			n_cbra = new_child.as(TCbra)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_op == old_child then
			n_op = new_child.as(TPluseq)
			return
		end
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_op == old_child then
			n_op = new_child.as(TMinuseq)
			return
		end
	end