public static TypeSymbol MakeClassTemplateInstance(Root root, IReadOnlyList<GenericsInstance> inst, TypeSymbol baseType)
{
var g = baseType as GenericSymbol;
if(g != null)
{
var i = FindGenericIndex(inst, g);
if (i == -1)
{
return baseType;
}
return inst[i].Type;
}
else if (baseType.Generics.Count > 0 || baseType.TacitGeneric.Count > 0)
{
var prm = new List<TypeSymbol>();
foreach (var v in baseType.Generics)
{
var t = MakeClassTemplateInstance(root, inst, v);
prm.Add(t);
}
var tprm = new List<TypeSymbol>();
foreach (var v in baseType.TacitGeneric)
{
var t = MakeClassTemplateInstance(root, inst, v);
tprm.Add(t);
}
return root.ClassManager.Issue(baseType, prm, tprm);
}
else
{
return baseType;
}
}
public DyadicOperatorSymbol(TokenType type, TypeSymbol left, TypeSymbol right, TypeSymbol ret)
: base(RoutineType.FunctionOperator, type)
{
Name = GetOperatorName(type);
CalculateType = type;
_Arguments = ArgumentSymbol.MakeParameters(left, right);
_CallReturnType = ret;
}
public EnumSymbol(string name, ProgramContext block, IReadOnlyList<AttributeSymbol> attr, TypeSymbol bt)
{
Name = name;
Block = block;
_Attribute = attr;
_BaseType = bt;
AppendChild(Block);
}
public PropertySymbol(string name, TypeSymbol type, bool isSet)
: base(RoutineType.Routine, TokenType.Unknoun)
{
Name = name;
Type = type;
IsSet = isSet;
_Attribute = null;
_Arguments = null;
}
private static bool ContainSubType(TypeSymbol from, TypeSymbol to)
{
foreach(var v in from.EnumSubType())
{
if(v == to)
{
return true;
}
}
return false;
}
public RoutineSymbol FindMonadic(TokenType op, TypeSymbol expt)
{
var s = OpList[op].FindAll(v => v.Arguments[0].ReturnType == expt);
if (s.Count == 1)
{
return s[0];
}
else
{
return Root.ErrorRoutine;
}
}
public ClassTemplateInstance(TypeSymbol type, IReadOnlyList<TypeSymbol> parameters, IReadOnlyList<TypeSymbol> tacitParameters)
: base(ClassType.Unknown)
{
//if (type.Generics.Count != parameters.Count || type.TacitGeneric.Count != tacitParameters.Count)
//{
// throw new ArgumentException("parameter count");
//}
Type = type;
Parameters = parameters;
TacitParameters = tacitParameters;
InitializeChildSymbols();
}
public RoutineSymbol FindDyadic(TokenType op, TypeSymbol left, TypeSymbol right)
{
var s = OpList[op].FindAll(v => v.Arguments[0].ReturnType == left && v.Arguments[1].ReturnType == right);
if (s.Count > 0)
{
return s[0];
}
else if(left == right)
{
return new DyadicOperatorSymbol(op, left, right, left);
}
else
{
return Root.ErrorRoutine;
}
}
public RoutineSymbol Find(TypeSymbol from, TypeSymbol to)
{
var s = ConvList.FindAll(v => v.CallReturnType == to && v.Arguments[0].ReturnType == from);
if(s.Count == 1)
{
return s[0];
}
else if(s.Count > 1)
{
return Root.ErrorRoutine;
}
else
{
if (ContainSubType(from, to))
{
return Root.Default;
}
else
{
return Root.ErrorRoutine;
}
}
}
public new void Initialize(string name, VariantType type, IReadOnlyList<AttributeSymbol> attr, TypeSymbol dt, Element def)
{
base.Initialize(name, type, attr, dt, def);
}
internal static OverLoadTypeMatch MakeMatch(Root root, TypeSymbol type, IReadOnlyList<GenericSymbol> fg, IReadOnlyList<GenericsInstance> inst, IReadOnlyList<TypeSymbol> ag)
{
var ig = new List<TypeSymbol>();
var result = new OverLoadTypeMatch()
{
Type = type,
FormalGenerics = fg,
ScopeInstance = inst,
ActualGenerics = ag,
InstanceGenerics = ig,
};
if (TypeSymbol.HasAnyErrorType(fg))
{
result.Result = TypeMatchResult.Unknown;
return result;
}
if (!ContainGenericCount(fg, ag))
{
result.Result = TypeMatchResult.UnmatchGenericCount;
return result;
}
InitInstance(fg, ag, ig);
var tgi = InferInstance(root, inst, ag, ig);
if (TypeSymbol.HasAnyErrorType(tgi))
{
result.Result = TypeMatchResult.UnmatchGenericType;
return result;
}
result.Result = TypeMatchResult.PerfectMatch;
result.Type = GenericsInstance.MakeClassTemplateInstance(root, tgi, type);
return result;
}
internal static OverLoadTypeMatch MakeUnknown(TypeSymbol type)
{
return new OverLoadTypeMatch { Type = type, Result = TypeMatchResult.Unknown };
}
internal static OverLoadTypeMatch MakeNotType(TypeSymbol type)
{
return new OverLoadTypeMatch { Type = type, Result = TypeMatchResult.NotType };
}
public void Initialize(string name, RoutineType type, TokenType opType, IReadOnlyList<AttributeSymbol> attr, IReadOnlyList<GenericSymbol> gnr, IReadOnlyList<ArgumentSymbol> arg, TypeSymbol rt)
{
if (IsInitialize)
{
throw new InvalidOperationException();
}
IsInitialize = true;
Name = name;
RoutineType = type;
OperatorType = opType;
Block = new ProgramContext();
_Attribute = attr;
_Generics = gnr;
_Arguments = arg;
_CallReturnType = rt;
AppendChild(Block);
}
public void Initialize(string name, VariantType type, IReadOnlyList<AttributeSymbol> attr, TypeSymbol dt, Element def = null)
{
if(IsInitialize)
{
throw new InvalidOperationException();
}
IsInitialize = true;
Name = name;
VariantType = type;
DefaultValue = def;
AppendChild(DefaultValue);
_Attribute = attr;
_DataType = dt;
}
internal static IReadOnlyList<TypeSymbol> MakeArgument(int count, TypeSymbol scope)
{
if (count < 0)
{
throw new ArgumentException("count");
}
var ret = new List<TypeSymbol>();
for (var i = 0; i < count; ++i)
{
ret.Add(scope);
}
return ret;
}
private static TypeSymbol GetCommonSubType(TypeSymbol t1, TypeSymbol t2)
{
return t1; //todo 処理の順序で結果が変わるバグに対処する。共通のサブタイプを返すようにする。
}
public DefaultSymbol(string name, TypeSymbol parent)
: base(RoutineType.Routine, TokenType.Unknoun)
{
Name = name;
_CallReturnType = parent;
}
internal static bool HasAnyErrorType(TypeSymbol scope)
{
var cti = scope as ClassTemplateInstance;
if(cti != null)
{
if (HasAnyErrorType(cti.Parameters) || HasAnyErrorType(cti.TacitGeneric))
{
return true;
}
}
else if (scope is VoidSymbol || scope is UnknownSymbol || scope is ErrorTypeSymbol)
{
return true;
}
return false;
}
public IEnumerable<RoutineSymbol> GetAllInitializer(TypeSymbol type)
{
return ConvList.FindAll(v => v.CallReturnType == type);
}