public InitializerInfo(IInitializableObject owner)
: base(InitializerInfo.GetHeading(owner), InitializerInfo.GetImageKey(owner))
{
if (owner == null)
{
throw new ArgumentNullException();
}
if ((owner.Initializer == null) || String.IsNullOrWhiteSpace(owner.Initializer.Source))
{
throw new ArgumentException();
}
this.Owner = owner;
this.Initializer = owner.Initializer;
this.SortOrder = this.Initializer.SortKey;
}
private bool NeedRewriteInitializer(InitializerExpressionSyntax initializer, List <InitializerInfo> infos, ref bool extensionMethodExists, ref bool isImplicitElementAccessSyntax)
{
bool need = false;
foreach (var init in initializer.Expressions)
{
var info = new InitializerInfo();
infos.Add(info);
var ae = init as AssignmentExpressionSyntax;
if (ae?.Right is InitializerExpressionSyntax)
{
info.nested = new List <InitializerInfo>();
if (NeedRewriteInitializer((InitializerExpressionSyntax)ae.Right, info.nested, ref extensionMethodExists, ref isImplicitElementAccessSyntax))
{
need = true;
}
}
else
{
var collectionInitializer = this.semanticModel.GetCollectionInitializerSymbolInfo(init).Symbol;
var mInfo = collectionInitializer != null ? collectionInitializer as IMethodSymbol : null;
if (mInfo != null)
{
info.method = mInfo;
if (mInfo.IsExtensionMethod)
{
extensionMethodExists = true;
}
need = true;
}
if (init.Kind() == SyntaxKind.SimpleAssignmentExpression)
{
var be = (AssignmentExpressionSyntax)init;
if (be.Left is ImplicitElementAccessSyntax)
{
isImplicitElementAccessSyntax = true;
need = true;
}
}
}
}
return(need);
}
public override void Visit(ImportSyntax pNode)
{
if (!_importPath.Contains(pNode.Path))
{
_importPath.Add(pNode.Path);
var path = System.IO.Path.GetFullPath(System.IO.Path.Combine(_path, pNode.Path + ".dll"));
Assembly asm = null;
try
{
asm = Assembly.LoadFile(path);
}
catch (Exception)
{
Compiler.ReportError(CompilerErrorType.InvalidImport, pNode, pNode.Path);
return;
}
try
{
System.IO.File.Copy(path, System.IO.Path.Combine(_path, System.IO.Path.GetFileName(path)), true);
}
catch (Exception)
{
Compiler.ReportError("Unable to copy import to local directory");
}
//Import all types from the import
//TODO move this to struct definition thing?
foreach (var t in asm.GetTypes())
{
if (t.IsValueType && t.IsPublic)
{
string prefix = "";
var attr = t.GetCustomAttributes <Emitting.TypePrefixAttribute>().SingleOrDefault();
//All exported types must have a TypePrefixAttribute in order to be imported
if (attr != null)
{
//
//Create type
//
prefix = attr.Prefix;
//Get any generic type parameters of the type
List <string> typeParameters = new List <string>();
if (t.IsGenericType)
{
var ga = t.GetGenericArguments();
for (int i = 0; i < ga.Length; i++)
{
typeParameters.Add(ga[i].Name);
}
}
var st = SmallType.RegisterType(pNode.Alias, prefix, true, typeParameters);
st.SetSystemType(t);
foreach (var f in t.GetFields())
{
SmallType fieldType = null;
if (f.FieldType.IsGenericParameter)
{
//If it's a generic type parameter, use the generic type
foreach (var s in st.GenericTypeParameters)
{
if (s.Name.Equals(f.FieldType.Name, StringComparison.OrdinalIgnoreCase))
{
fieldType = s;
}
}
}
else
{
fieldType = SmallType.FromSystemType(f.FieldType);
}
typeParameters.Clear();
//Get field type parameters
if (f.FieldType.ContainsGenericParameters)
{
var typeArguments = t.GetGenericArguments();
foreach (var tp in typeArguments)
{
if (tp.IsGenericParameter)
{
typeParameters.Add(tp.Name);
}
}
}
st.AddField(f.Name, typeParameters, fieldType);
}
//Check if we have an initializer function
var m = t.GetMethod("Initialize");
if (m != null)
{
var ii = new InitializerInfo(null);
ii.SetMethod(m);
st.SetInitializer(ii);
}
}
}
}
foreach (var t in asm.GetTypes())
{
foreach (var m in t.GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static))
{
var p = m.GetParameters();
MethodDefinition.Parameter[] parameters = new MethodDefinition.Parameter[p.Length];
for (int i = 0; i < p.Length; i++)
{
parameters[i] = new MethodDefinition.Parameter(SmallType.FromSystemType(p[i].ParameterType), p[i].Name, p[i].ParameterType.IsByRef);
}
SmallType[] returnType;
if (m.ReturnType.IsConstructedGenericType)
{
var types = m.ReturnType.GetGenericArguments();
returnType = new SmallType[types.Length];
for (int i = 0; i < types.Length; i++)
{
returnType[i] = SmallType.FromSystemType(types[i]);
}
}
else if (m.ReturnType.IsGenericParameter)
{
returnType = new SmallType[] { SmallType.CreateGenericParameter(m.ReturnType.Name) };
}
else if (m.ReturnType != typeof(void))
{
returnType = new SmallType[] { SmallType.FromSystemType(m.ReturnType) }
}
;
else
{
returnType = new SmallType[0];
}
List <SmallType> typeHints = new List <SmallType>();
if (m.IsGenericMethodDefinition)
{
var typeParameters = m.GetGenericArguments();
foreach (var tp in typeParameters)
{
if (tp.IsGenericParameter)
{
typeHints.Add(SmallType.CreateGenericParameter(tp.Name));
}
}
}
MethodDefinition md = null;
if (returnType.Length == 1 && parameters.Length == 1 &&
m.Name == MetadataCache.CastFunction(parameters[0].Type, returnType[0]))
{
md = MetadataCache.AddImportedCast(pNode.Alias, parameters[0].Type, parameters[0].Name, returnType[0]);
}
else
{
md = MetadataCache.AddImportedMethod(pNode.Alias, m.Name, parameters, returnType, typeHints);
}
md.SetExternMethod(m);
}
}
}
if (MetadataCache.ImportedNamespaces().Contains(pNode.Alias))
{
Compiler.ReportError(CompilerErrorType.DuplicateImportAlias, pNode, pNode.Alias);
}
else
{
MetadataCache.AddNamespace(pNode.Alias);
}
}
