public static UnifiedClassDefinition CreateClassDefinition(
Construct construct)
{
var klass = UnifiedClassDefinition.Create();
ParseClass(construct, klass.Body);
return(klass);
}
public static UnifiedClassDefinition CreateModule(XElement node)
{
Contract.Requires(node != null);
Contract.Requires(node.Name() == "module");
return(UnifiedClassDefinition.Create(
null, null, CreateSymbol(node.NthElement(0)), null,
null,
CreateScope(node.NthElement(1))));
}
/// <summary>
/// クラス内から public なインスタンスフィールドを検索して取得します
/// </summary>
/// <param name="cls"> クラスオブジェクト </param>
/// <returns> public なインスタンスフィールドの UnifiedVariableDefinition オブジェクトの集合 </returns>
public static IEnumerable<UnifiedVariableDefinition> FindPublicFields(
UnifiedClassDefinition cls)
{
return cls.Descendants<UnifiedVariableDefinition>()
.Where(
e => e.Modifiers
.Any(m => m.Name == "public"))
.Where(
e => e.Modifiers
.All(m => m.Name != "static"));
}
public static UnifiedClassDefinition CreateClass(XElement node)
{
Contract.Requires(node != null);
Contract.Requires(node.Name() == "class");
var constNode = node.NthElement(1);
var constrain = constNode.Name() != "nil"
? UnifiedExtendConstrain.Create(
UnifiedType.Create(constNode.Value))
: null;
return(UnifiedClassDefinition.Create(
null, null, CreateSymbol(node.NthElement(0)), null,
constrain.ToSet <UnifiedTypeConstrain>(),
CreateScope(node.NthElement(2))));
}
public static Namespace GetNamespace(UnifiedClassDefinition classNode)
{
var type = NamespaceType.Class;
var className =
classNode.FirstDescendant<UnifiedVariableIdentifier>().Name;
var parents =
DetectorHelper.GetParentTypes(type).Select(
t => DetectorHelper.Namespace2UnifiedType(t));
var parentNode = DetectorHelper.GetFirstFoundNode(
classNode, parents);
return new Namespace {
Value = className,
NamespaceType = type,
Parent = Dispatcher(parentNode),
};
}
public override bool Visit(
UnifiedClassDefinition element, VisitorArgument arg)
{
element.Annotations.TryAccept(this, arg);
element.Modifiers.TryAccept(this, arg);
Writer.Write("class");
Writer.Write(" ");
element.Name.TryAccept(this, arg);
Writer.Write(":");
Writer.Write(" # ");
element.GenericParameters.TryAccept(this, arg);
element.Constrains.TryAccept(this, arg);
Writer.WriteLine();
element.Body.TryAccept(this, arg.IncrementDepth());
return false;
}
public override bool Visit(
UnifiedClassDefinition element, VisitorArgument arg)
{
element.Annotations.TryAccept(this, arg);
element.Modifiers.TryAccept(this, arg);
Writer.Write("class");
Writer.Write(" ");
element.Name.TryAccept(this, arg);
Writer.Write(":");
Writer.Write(" # ");
element.GenericParameters.TryAccept(this, arg);
element.Constrains.TryAccept(this, arg);
Writer.WriteLine();
element.Body.TryAccept(this, arg.IncrementDepth());
return(false);
}
public override bool Visit(
UnifiedClassDefinition element, VisitorArgument arg)
{
return Visit(element, arg, "class");
}
public override bool Visit(
UnifiedClassDefinition element, VisitorArgument arg)
{
element.Body.TryAccept(this, arg.Set(ForBlock));
return(true);
}
public override bool Visit(
UnifiedClassDefinition element, VisitorArgument arg)
{
element.Body.TryAccept(this, arg.Set(ForBlock));
return true;
}
public UnifiedElement VisitTypeDeclaration(
TypeDeclaration dec, object data)
{
var attrs = dec.Attributes.AcceptVisitorAsAttrs(this, data);
var mods = LookupModifiers(dec.Modifiers);
var name = UnifiedVariableIdentifier.Create(dec.Name);
var typeParams = dec.TypeParameters.AcceptVisitorAsTypeParams(
this, data);
if (typeParams.Count == 0)
{
typeParams = null;
}
var extends = dec.BaseTypes.AcceptVisitorAsConstrains(this, data);
var body = UnifiedBlock.Create();
foreach (var node in dec.Members)
{
var uExpr = node.TryAcceptForExpression(this);
if (uExpr != null)
{
body.Add(uExpr);
}
}
// set constraint
var dic = CreateDictionary(dec.Constraints);
if (typeParams != null)
{
foreach (
var generic in
typeParams.Descendants <UnifiedGenericParameter>(
))
{
var tName = GetTypeName(generic.Type);
if (dic.ContainsKey(tName))
{
foreach (var c in dic[tName])
{
if (generic.Constrains == null)
{
generic.Constrains =
UnifiedSet <UnifiedTypeConstrain> .Create();
}
generic.Constrains.Add(c.DeepCopy());
}
}
}
}
foreach (
var generic in
extends.Descendants <UnifiedGenericParameter>())
{
var tName = GetTypeName(generic.Type);
if (dic.ContainsKey(tName))
{
foreach (var c in dic[tName])
{
if (generic.Constrains == null)
{
generic.Constrains =
UnifiedSet <UnifiedTypeConstrain> .Create();
}
generic.Constrains.Add(c.DeepCopy());
}
}
}
switch (dec.ClassType)
{
case ClassType.Class:
return(UnifiedClassDefinition.Create(
attrs, mods, name, typeParams, extends, body));
case ClassType.Struct:
return(UnifiedStructDefinition.Create(
attrs, mods, name, typeParams, extends, body));
case ClassType.Interface:
return(UnifiedInterfaceDefinition.Create(
attrs, mods, name, typeParams, extends, body));
case ClassType.Enum:
return(UnifiedEnumDefinition.Create(
attrs, mods, name, typeParams, extends, body));
}
var msg = "LookupClassKind : " + dec.ClassType + "には対応していません。";
throw new InvalidOperationException(msg);
}
public override bool Visit(
UnifiedClassDefinition element, VisitorArgument arg)
{
return(Visit(element, arg, "class"));
}
