public GlobalScope()
{
globals = new BindingDictionary();
DataType @int = NamedType.Integer;
DataType @bool = NamedType.Boolean;
DataType integerOperation = NamedType.Function(new[] { @int, @int }, @int);
DataType integerComparison = NamedType.Function(new[] { @int, @int }, @bool);
DataType booleanOperation = NamedType.Function(new[] { @bool, @bool }, @bool);
globals["<"] = integerComparison;
globals["<="] = integerComparison;
globals[">"] = integerComparison;
globals[">="] = integerComparison;
globals["=="] = integerComparison;
globals["!="] = integerComparison;
globals["+"] = integerOperation;
globals["*"] = integerOperation;
globals["/"] = integerOperation;
globals["-"] = integerOperation;
globals["&&"] = booleanOperation;
globals["||"] = booleanOperation;
globals["!"] = NamedType.Function(new[] { @bool }, @bool);
var T = TypeVariable.CreateGeneric(); //TypeVariable 0
var S = TypeVariable.CreateGeneric(); //TypeVariable 1
var enumerableT = NamedType.Enumerable(T);
var nullableT = NamedType.Nullable(T);
var vectorT = NamedType.Vector(T);
var enumerableS = NamedType.Enumerable(S);
globals["??"] = NamedType.Function(new DataType[] { nullableT, T }, T);
globals["Print"] = NamedType.Function(new[] { T }, NamedType.Void);
globals["Nullable"] = NamedType.Function(new[] { T }, nullableT);
globals["First"] = NamedType.Function(new[] { enumerableT }, T);
globals["Take"] = NamedType.Function(new[] { enumerableT, @int }, enumerableT);
globals["Skip"] = NamedType.Function(new[] { enumerableT, @int }, enumerableT);
globals["Any"] = NamedType.Function(new[] { enumerableT }, @bool);
globals["Count"] = NamedType.Function(new[] { enumerableT }, @int);
globals["Select"] = NamedType.Function(new[] { enumerableT, NamedType.Function(new[] { T }, S) }, enumerableS);
globals["Where"] = NamedType.Function(new[] { enumerableT, NamedType.Function(new[] { T }, @bool) }, enumerableT);
globals["Each"] = NamedType.Function(new[] { vectorT }, enumerableT);
globals[ReservedName.__index__] = NamedType.Function(new[] { vectorT, @int }, T);
globals[ReservedName.__slice__] = NamedType.Function(new[] { vectorT, @int, @int }, vectorT);
globals["Append"] = NamedType.Function(new DataType[] { vectorT, T }, vectorT);
globals["With"] = NamedType.Function(new[] { vectorT, @int, T }, vectorT);
}
public void FailsTypeCheckingForNamesThatAreNotConstructorNames()
{
ShouldFailTypeChecking("new Foo()", Foo => Integer).WithError("Cannot construct 'Foo' because it is not a type.", 1, 5);
ShouldFailTypeChecking("new Foo()", Foo => NamedType.Function(Integer)).WithError("Cannot construct 'Foo' because it is not a type.", 1, 5);
}
public ExecutionDocumentWalkerOptions Add(object visitor)
{
if (visitor is IVisit <ExecutableDocument> ed)
{
ExecutableDocument.Add(ed);
}
if (visitor is IVisit <FragmentDefinition> fd)
{
FragmentDefinition.Add(fd);
}
if (visitor is IVisit <OperationDefinition> od)
{
OperationDefinition.Add(od);
}
if (visitor is IVisit <SelectionSet> ss)
{
SelectionSet.Add(ss);
}
if (visitor is IVisit <ISelection> s)
{
Selection.Add(s);
}
if (visitor is IVisit <FieldSelection> fs)
{
FieldSelection.Add(fs);
}
if (visitor is IVisit <InlineFragment> ift)
{
InlineFragment.Add(ift);
}
if (visitor is IVisit <FragmentSpread> fgs)
{
FragmentSpread.Add(fgs);
}
if (visitor is IVisit <Argument> arg)
{
Argument.Add(arg);
}
if (visitor is IVisit <NamedType> nt)
{
NamedType.Add(nt);
}
if (visitor is IVisit <VariableDefinition> vd)
{
VariableDefinition.Add(vd);
}
if (visitor is IVisit <DefaultValue> dv)
{
DefaultValue.Add(dv);
}
if (visitor is IVisit <Value> v)
{
Value.Add(v);
}
if (visitor is IVisit <Directive> d)
{
Directive.Add(d);
}
if (visitor is IVisit <TypeBase> t)
{
Type.Add(t);
}
return(this);
}
public override Void Visit(NamedType node, Void param)
{
Debug.Assert(false, $"{nameof(NamedType)} reached but it should have been removed already");
return(base.Visit(node, param));
}
protected bool Equals(NamedType other)
{
return(string.Equals(Name, other.Name));
}
public override object Visit(NamedType that, object value = null)
{
// Attempt to recursively resolve the reference, starting at the appropriate scope and looking upwards.
return that.Reference.Visit(this, value);
}
public override object Visit(NamedType that, object value = null)
{
PrintPrologue(that);
_writer.WriteLine("TypeKind = {0}", that.TypeKind.ToString());
PrintNodeId("Reference", that.Reference);
PrintNodeId("Type", that.Type);
PrintEpilogue(that);
that.Reference.Visit(this);
that.Type.Visit(this);
return null;
}
protected string GetCSTypeFull(NamedType type)
{
var fullName = TypeHelper.GetCSType(type, Settings, false, false, GetFullNamespace(type, Settings.Namespace, Settings.Structure));
return(TrimNamespace(fullName));
}
private static DataType Function(IEnumerable <DataType> parameterTypes, DataType returnType)
{
return(NamedType.Function(parameterTypes, returnType));
}
public static int GetHashCode(Type type, string?name) => NamedType.GetHashCode(type, name) & UnityContainer.HashMask;
/** Parses a \c guard definition, which makes a \c value accessible through the a getter and/or a setter.
*
* guard Foo is io .foo:
* get:
* return .foo
* set:
* .foo := 2 * value
*/
private GuardStatement ParseGuardStatement()
{
Token start = _matcher.Match(TokenKind.Keyword_Guard);
_matcher.Match(TokenKind.Space);
SymbolDefinition name = ParseSymbolDefinition(SymbolKind.Guard);
#if false
Token @base = null;
if (_matcher.This.Kind == TokenKind.Dot)
{
_matcher.Match(TokenKind.Dot);
@base = name;
@name = _matcher.Match(TokenKind.Name);
}
#endif
_matcher.Match(TokenKind.Space);
_matcher.Match(TokenKind.Keyword_Is);
_matcher.Match(TokenKind.Space);
DirectionKind direction = ParseDirection();
_matcher.Match(TokenKind.Space);
#if DONE
Expression member = ParseInstanceExpression();
#else
_matcher.Match(TokenKind.Dot);
Token token = _matcher.Match(TokenKind.Name);
SymbolReference reference = new SymbolReference(token.Cursor, PathKind.Instance, token.Text);
Type type = new NamedType(token.Cursor, reference);
#endif
Statement getter = null;
Statement setter = null;
if (_matcher.This.Kind == TokenKind.Colon)
{
_matcher.Match(TokenKind.Colon);
_matcher.Match(TokenKind.EndOfLine);
token = _matcher.Match(TokenKind.Indent); // NOTE: Update 'token'!
switch (direction)
{
case DirectionKind.Out:
getter = ParseGetRoutine((Type) type.Clone());
break;
case DirectionKind.In:
setter = ParseSetRoutine((Type) type.Clone());
break;
case DirectionKind.InOut:
if (_matcher.This.Kind == TokenKind.Keyword_Get)
getter = ParseGetRoutine((Type) type.Clone());
if (_matcher.This.Kind == TokenKind.Keyword_Set)
setter = ParseSetRoutine((Type) type.Clone());
if (getter == null && setter == null)
throw new ParserError(token.Cursor, "Getter or setter must be specified after colon");
break;
default:
throw new System.ArgumentException("direction");
}
_matcher.Match(TokenKind.Dedent);
}
if (getter == null)
{
if (direction != DirectionKind.In)
getter = CreateDefaultGetter(token.Cursor, token.Text);
else
getter = new NoneStatement(token.Cursor);
}
if (setter == null)
{
if (direction != DirectionKind.Out)
setter = CreateDefaultSetter(token.Cursor, token.Text);
else
setter = new NoneStatement(token.Cursor);
}
return new GuardStatement(start.Cursor, name, direction, type, getter, setter);
}
public static int GetHashCode(Type type) => NamedType.GetHashCode(type.GetHashCode(), -1) & UnityContainer.HashMask;
public virtual void Enter(NamedType namedType)
{
}
public virtual void Leave(NamedType namedType)
{
}
public KnownTypeNamesError(ValidationContext context, NamedType node, string[] suggestedTypes)
: base(context.OriginalQuery, NUMBER, UnknownTypeMessage(node.Name, suggestedTypes), node)
{
}
public void Add(NamedType namedType)
{
this.typeNames.Add(namedType);
}
static void Main(string[] args)
{
Console.WriteLine("Starting...");
string location = args.Length > 0 ? args[0] : Console.ReadLine();
const string argStart = "--converter:";
string converterV = args.FirstOrDefault(v => v.StartsWith(argStart));
if (converterV == null)
{
Console.WriteLine(@"What software would you like to convert for?
Currently Supported:
Bridge,
DuoCode");
}
string converterValue = converterV == null?Console.ReadLine() : converterV.Substring(argStart.Length);
ConversionSoftware conversionSoftware = (ConversionSoftware)Enum.Parse(typeof(ConversionSoftware), converterValue);
string file;
Console.WriteLine("Reading file...");
try
{
file = File.ReadAllText(location);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return;
}
var parser = new MTypescriptParser
{
ParseString = file
};
Console.WriteLine("Parsing...");
parser.Parse();
Namespace globalNamespace = parser.globalNamespace;
var converter = new TypescriptToCSConverter(conversionSoftware);
globalNamespace.classes.AddRange(new[]
{
new TypeDeclaration
{
name = "NullType"
},
new TypeDeclaration
{
name = "UndefinedType",
fields = new List <Field>
{
new Field
{
name = "Undefined",
@readonly = true,
@static = true,
template = "undefined",
type = new NamedType
{
Name = "UndefinedType"
}
}
}
},
new TypeDeclaration
{
name = "VoidType",
implements = new List <TypescriptParser.Type>
{
new NamedType {
Name = "UndefinedType"
}
}
},
new TypeDeclaration
{
name = "Symbol",
methods = new List <MethodOrDelegate>
{
new MethodOrDelegate
{
Arguments = new Arguments
{
Parameters = new List <Parameter>
{
new Parameter
{
Name = "value",
Type = new NamedType
{
Name = "string"
}
}
}
},
Name = "constructor"
},
new MethodOrDelegate
{
Name = "constructor"
}
}
}
});
converter.globalNamespace = globalNamespace;
//Console.WriteLine("Dotting...");
//globalNamespace.ForeachTypeReference(v =>
//{
// NamedType namedType = v as NamedType;
// if (string.IsNullOrEmpty(namedType?.Name))
// return;
// string[] dots = namedType.Name.Split('.');
// string[] preDots = new string[dots.Length - 1];
// Array.Copy(dots, preDots, dots.Length - 1);
// namedType.PreDots = preDots;
// namedType.Name = dots.Last();
//});
//Console.WriteLine("Merging...");
//converter.MergeEnums(globalNamespace);
//converter.RemoveAll(globalNamespace);
Console.WriteLine("Referencing...");
globalNamespace.ForeachTypeReference(converter.Reference);
globalNamespace.ForeachType(v => converter.Reference(v.Type));
Console.WriteLine("Unioning...");
parser.Unions.ForEach(v =>
{
var typeA = v.Generics.Generic[0] as NamedType;
var typeB = v.Generics.Generic[1] as NamedType;
var typeDeclA = typeA.TypeDeclaration;
var typeDeclB = typeB.TypeDeclaration;
NamedType result;
if (typeDeclA == null || typeDeclB == null)
{
result = new NamedType
{
Name = "object"
}
}
;
else
{
var shared = typeDeclA.FindSharedInterfaces(typeDeclB).Cast <TypescriptParser.Type>().ToList();
shared.Insert(0, new NamedType
{
Name = "Union",
Generics = new Generics
{
Generic = new List <TypescriptParser.Type>
{
typeA, typeB
}
}
});
string name = "Union_" + converter.Convert(typeA) + "_" + converter.Convert(typeB);
TypeDeclaration @ref = null;
globalNamespace.ForeachType(v2 => @ref = v2.name == name ? v2 : @ref);
bool create = @ref == null;
if (create)
{
@ref = new TypeDeclaration
{
name = name,
implements = shared,
IsUnion = true,
GenericDeclaration = new GenericDeclaration
{
Generics = new List <string> {
"A", "B"
}
}
}
}
;
v.Name = name;
v.TypeDeclaration = @ref;
if (create)
{
globalNamespace.classes.Add(@ref);
}
}
});
Console.WriteLine("Renaming...");
globalNamespace.ForeachType((Action <MethodOrDelegate>)(typeDeclaration =>
{
var delegatesFound = globalNamespace.FindType(new NamedType
{
Name = typeDeclaration.Name,
Generics = new Generics
{
Generic = typeDeclaration.GenericDeclaration.Generics.ConvertAll <TypescriptParser.Type>(v2 => new NamedType {
Name = v2
})
}
}, converter.remove).delegatesFound;
if (delegatesFound.Count > 1)
{
typeDeclaration.Name += "_" + delegatesFound.Count;
}
}));
Console.WriteLine("Removing duplicate fields...");
converter.RemoveDuplicateFields();
Console.WriteLine("Translating...");
List <TypeDeclaration> toAdd = new List <TypeDeclaration>();
globalNamespace.ForeachType(v => toAdd.AddRange(converter.Translate(v)));
globalNamespace.ForeachType(v => converter.Cleanse(v.Type, v.GenericDeclaration, null));
globalNamespace.classes.AddRange(toAdd);
converter.remove.Clear();
globalNamespace.ForeachType(converter.DeleteUnneededTypes);
converter.RemoveAll(globalNamespace);
Console.WriteLine("Writing C#...");
//converter.ConvertUsingStatements(globalNamespace);
converter.Result.Append(conversionSoftware == ConversionSoftware.Bridge ? "using Bridge;" : "using DuoCode.Runtime;");
converter.Result.Append(
@"
//using number = System.Double;
//using any = Bridge.Union<System.Delegate, object>;
//using boolean = System.Boolean;
#pragma warning disable CS0626
#pragma warning disable CS0824
//[assembly: Convention(Notation.LowerCamelCase)]
");
converter.Convert(globalNamespace, false);
Console.WriteLine("Writing...");
File.WriteAllText($"{Path.GetFileNameWithoutExtension(location)}.cs", converter.Result.ToString());
Console.WriteLine("Exiting...");
}
protected virtual void ExitNamedType(TContext context, NamedType namedType)
{
}
protected bool Equals(NamedType other)
{
return string.Equals(Name, other.Name);
}
public void HasVectorTypeBasedOnTheTypeOfItsItemExpressions()
{
Type("[0, 1, 2]").ShouldEqual(NamedType.Vector(Integer));
Type("[true, false, true]").ShouldEqual(NamedType.Vector(Boolean));
}
public override object Visit(NamedType that, object value)
{
that.Reference.Visit(this, value);
return null;
}
public virtual object Visit(NamedType that, object value)
{
throw new System.NotImplementedException();
}