backup/cs2j
1
0
Fork 0
mirror of https://github.com/twiglet/cs2j.git synced 2025-01-18 13:15:17 +01:00
Code Issues Projects Releases Activity

be more careful about collecting the components of a qualified type. Do it via thedottedtext return value instead of relying on passing it via UnknownRepTemplate (that meant we would be looking for qualified type names when we shouldn't be)

Browse Source
This commit is contained in:
Kevin Glynn 2011-02-28 20:30:29 +01:00
parent 922f535dcc
commit 895b538ba0
1 changed files with 73 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

125
CSharpTranslator/antlr3/src/CS2JTranslator/CS2JTransform/NetMaker.g
View File

@ -517,6 +517,7 @@ scope {
CommonTree ret = null; CommonTree ret = null;
TypeRepTemplate expType = SymTabLookup("this"); TypeRepTemplate expType = SymTabLookup("this");
bool implicitThis = true; bool implicitThis = true;
$thedottedtext = null;
} }
@after { @after {
if (ret != null) if (ret != null)
@ -581,7 +582,7 @@ scope {
$dotNetType = methodResult.ResultType; $dotNetType = methodResult.ResultType;
} }
else { else {
WarningFailedResolve($i2.tree.Token.Line, "Could not resolve method application against " + expType.TypeName); WarningFailedResolve($i2.tree.Token.Line, "Could not resolve method application of " + $i2.thetext + " against " + expType.TypeName);
} }
} }
| ^(APPLY {$primary_expression::parentIsApply = true; } expression {$primary_expression::parentIsApply = false; } argument_list?) | ^(APPLY {$primary_expression::parentIsApply = true; } expression {$primary_expression::parentIsApply = false; } argument_list?)
@ -603,7 +604,7 @@ scope {
Debug($d1.token.Line + ": '" + $i1.thetext + "' might be a property"); Debug($d1.token.Line + ": '" + $i1.thetext + "' might be a property");
$dotNetType = new UnknownRepTemplate(expType.TypeName+".DOTACCESS"); $dotNetType = new UnknownRepTemplate(expType.TypeName+".DOTACCESS."+ $i1.thetext);
ResolveResult fieldResult = expType.Resolve($i1.thetext, AppEnv); ResolveResult fieldResult = expType.Resolve($i1.thetext, AppEnv);
if (fieldResult != null) { if (fieldResult != null) {
@ -614,13 +615,22 @@ scope {
AddToImports(fieldResult.Result.Imports); AddToImports(fieldResult.Result.Imports);
$dotNetType = fieldResult.ResultType; $dotNetType = fieldResult.ResultType;
} }
else if ($e1.dotNetType.IsUnknownType) { else if ($e1.thedottedtext != null) {
string staticType = $e1.dotNetType + "." + $i1.thetext; string staticType = $e1.thedottedtext + "." + $i1.thetext;
$dotNetType = findType(staticType); $dotNetType = findType(staticType);
if (!$dotNetType.IsUnknownType) { if (!$dotNetType.IsUnknownType) {
AddToImports($dotNetType.Imports); AddToImports($dotNetType.Imports);
}
else {
// remember text so far
$thedottedtext = staticType;
} }
} }
else {
// Could not find identifier in e1's type and we aren't building up a static type reference, so emit warning
WarningFailedResolve($i1.tree.Token.Line, "Could not resolve identifier " + $i1.thetext + " against " + expType.TypeName);
}
} }
$rmId = $identifier.thetext; $rmId = $identifier.thetext;
} }
@ -673,6 +683,7 @@ scope {
if (!found) { if (!found) {
// Not a variable, not a property read, not a type, is it part of a type name? // Not a variable, not a property read, not a type, is it part of a type name?
$dotNetType = new UnknownRepTemplate($identifier.thetext); $dotNetType = new UnknownRepTemplate($identifier.thetext);
$thedottedtext = $identifier.thetext;
} }
} }
| primary_expression_start { $dotNetType = $primary_expression_start.dotNetType; } | primary_expression_start { $dotNetType = $primary_expression_start.dotNetType; }
@ -706,7 +717,7 @@ scope {
AddToImports(conResult.Result.Imports); AddToImports(conResult.Result.Imports);
$dotNetType = conResult.ResultType; $dotNetType = conResult.ResultType;
} }
else { else if ($argument_list.argTypes != null && $argument_list.argTypes.Count > 0) { // assume we have a zero-arg constructor, so don't print warning
WarningFailedResolve($n.token.Line, "Could not resolve constructor against " + conType.TypeName); WarningFailedResolve($n.token.Line, "Could not resolve constructor against " + conType.TypeName);
} }
} }
@ -794,9 +805,9 @@ member_declarator_list:
member_declarator (',' member_declarator)* ; member_declarator (',' member_declarator)* ;
member_declarator: member_declarator:
qid ('=' expression)? ; qid ('=' expression)? ;
primary_or_array_creation_expression returns [TypeRepTemplate dotNetType, string rmId, TypeRepTemplate typeofType]: primary_or_array_creation_expression returns [TypeRepTemplate dotNetType, string rmId, TypeRepTemplate typeofType, string thedottedtext]:
(array_creation_expression) => array_creation_expression { $dotNetType = $array_creation_expression.dotNetType; } (array_creation_expression) => array_creation_expression { $dotNetType = $array_creation_expression.dotNetType; $thedottedtext = null; }
| primary_expression { $dotNetType = $primary_expression.dotNetType; $rmId = $primary_expression.rmId; $typeofType = $primary_expression.typeofType; } | primary_expression { $dotNetType = $primary_expression.dotNetType; $rmId = $primary_expression.rmId; $typeofType = $primary_expression.typeofType; $thedottedtext = $primary_expression.thedottedtext; }
; ;
// new Type[2] { } // new Type[2] { }
array_creation_expression returns [TypeRepTemplate dotNetType]: array_creation_expression returns [TypeRepTemplate dotNetType]:
@ -1051,9 +1062,10 @@ statement_list:
/////////////////////////////////////////////////////// ///////////////////////////////////////////////////////
// Expression Section // Expression Section
/////////////////////////////////////////////////////// ///////////////////////////////////////////////////////
expression returns [TypeRepTemplate dotNetType, string rmId, TypeRepTemplate typeofType]: expression returns [TypeRepTemplate dotNetType, string rmId, TypeRepTemplate typeofType, string thedottedtext]
(unary_expression assignment_operator) => assignment { $dotNetType = VoidType; } :
| non_assignment_expression { $dotNetType = $non_assignment_expression.dotNetType; $rmId = $non_assignment_expression.rmId; $typeofType = $non_assignment_expression.typeofType; } (unary_expression assignment_operator) => assignment { $dotNetType = VoidType; $thedottedtext = null;}
| non_assignment_expression { $dotNetType = $non_assignment_expression.dotNetType; $rmId = $non_assignment_expression.rmId; $typeofType = $non_assignment_expression.typeofType; $thedottedtext = $non_assignment_expression.thedottedtext; }
; ;
expression_list returns [List<TypeRepTemplate> expTypes, List<CommonTree> expTrees, List<TypeRepTemplate> expTreeTypeofTypes] expression_list returns [List<TypeRepTemplate> expTypes, List<CommonTree> expTrees, List<TypeRepTemplate> expTreeTypeofTypes]
@init { @init {
@ -1077,48 +1089,53 @@ assignment
((^('.' expression identifier generic_argument_list?) | identifier) assignment_operator) => ((^('.' expression identifier generic_argument_list?) | identifier) assignment_operator) =>
(^('.' se=expression i=identifier generic_argument_list?) | i=identifier { isThis = true;}) a=assignment_operator rhs=expression (^('.' se=expression i=identifier generic_argument_list?) | i=identifier { isThis = true;}) a=assignment_operator rhs=expression
{ {
TypeRepTemplate seType = (isThis ? SymTabLookup("this") : $se.dotNetType); if (isThis && SymTabLookup($i.thetext) != null) {
if (seType == null) { // a simple variable assignment
seType = new UnknownRepTemplate("FIELD.BASE");
} }
if (seType.IsUnknownType) { else {
WarningFailedResolve($i.tree.Token.Line, "Could not find type of expression for field /property access"); TypeRepTemplate seType = (isThis ? SymTabLookup("this") : $se.dotNetType);
} if (seType == null) {
ResolveResult fieldResult = seType.Resolve($i.thetext, AppEnv); seType = new UnknownRepTemplate("FIELD.BASE");
if (fieldResult != null) { }
if (fieldResult.Result is PropRepTemplate) { if (seType.IsUnknownType) {
PropRepTemplate propRep = fieldResult.Result as PropRepTemplate; WarningFailedResolve($i.tree.Token.Line, "Could not find type of expression for field /property access");
if (!String.IsNullOrEmpty(propRep.JavaSet)) { }
CommonTree newRhsExp = $rhs.tree; ResolveResult fieldResult = seType.Resolve($i.thetext, AppEnv);
// if assignment operator is a short cut operator then only translate if we also have JavaGet if (fieldResult != null) {
bool goodTx = true; if (fieldResult.Result is PropRepTemplate) {
if ($a.tree.Token.Type != ASSIGN) { PropRepTemplate propRep = fieldResult.Result as PropRepTemplate;
if (!String.IsNullOrEmpty(propRep.JavaGet)) { if (!String.IsNullOrEmpty(propRep.JavaSet)) {
// we have prop <op>= rhs CommonTree newRhsExp = $rhs.tree;
// need to translate to setProp(getProp <op> rhs) // if assignment operator is a short cut operator then only translate if we also have JavaGet
Dictionary<string,CommonTree> rhsMap = new Dictionary<string,CommonTree>(); bool goodTx = true;
if (!isThis) if ($a.tree.Token.Type != ASSIGN) {
rhsMap["this"] = wrapExpression($se.tree, $i.tree.Token); if (!String.IsNullOrEmpty(propRep.JavaGet)) {
CommonTree rhsPropTree = mkJavaWrapper(propRep.JavaGet, rhsMap, $a.tree.Token); // we have prop <op>= rhs
newRhsExp = mkOpExp(mkOpExp($a.tree), rhsPropTree, $rhs.tree); // need to translate to setProp(getProp <op> rhs)
Dictionary<string,CommonTree> rhsMap = new Dictionary<string,CommonTree>();
if (!isThis)
rhsMap["this"] = wrapExpression($se.tree, $i.tree.Token);
CommonTree rhsPropTree = mkJavaWrapper(propRep.JavaGet, rhsMap, $a.tree.Token);
newRhsExp = mkOpExp(mkOpExp($a.tree), rhsPropTree, $rhs.tree);
}
else {
goodTx = false;
}
} }
else { Dictionary<string,CommonTree> valMap = new Dictionary<string,CommonTree>();
goodTx = false; if (!isThis)
valMap["this"] = wrapExpression($se.tree, $i.tree.Token);
valMap["value"] = wrapExpression(newRhsExp, $i.tree.Token);
if (goodTx) {
ret = mkJavaWrapper(propRep.JavaSet, valMap, $a.tree.Token);
AddToImports(propRep.Imports);
} }
} }
Dictionary<string,CommonTree> valMap = new Dictionary<string,CommonTree>();
if (!isThis)
valMap["this"] = wrapExpression($se.tree, $i.tree.Token);
valMap["value"] = wrapExpression(newRhsExp, $i.tree.Token);
if (goodTx) {
ret = mkJavaWrapper(propRep.JavaSet, valMap, $a.tree.Token);
AddToImports(propRep.Imports);
}
} }
} }
} else {
else { WarningFailedResolve($i.tree.Token.Line, "Could not resolve field or property expression against " + seType.ToString());
WarningFailedResolve($i.tree.Token.Line, "Could not resolve field or property expression against " + seType.ToString()); }
} }
} }
| (^(INDEX expression expression_list?) assignment_operator) => | (^(INDEX expression expression_list?) assignment_operator) =>
@ -1180,11 +1197,14 @@ assignment
| unary_expression assignment_operator expression ; | unary_expression assignment_operator expression ;
unary_expression returns [TypeRepTemplate dotNetType, string rmId, TypeRepTemplate typeofType]: unary_expression returns [TypeRepTemplate dotNetType, string rmId, TypeRepTemplate typeofType, string thedottedtext]
@init {
$thedottedtext = null;
}:
//('(' arguments ')' ('[' | '.' | '(')) => primary_or_array_creation_expression //('(' arguments ')' ('[' | '.' | '(')) => primary_or_array_creation_expression
cast_expression { $dotNetType = $cast_expression.dotNetType; } cast_expression { $dotNetType = $cast_expression.dotNetType; }
| primary_or_array_creation_expression { $dotNetType = $primary_or_array_creation_expression.dotNetType; $rmId = $primary_or_array_creation_expression.rmId; $typeofType = $primary_or_array_creation_expression.typeofType; } | primary_or_array_creation_expression { $dotNetType = $primary_or_array_creation_expression.dotNetType; $rmId = $primary_or_array_creation_expression.rmId; $typeofType = $primary_or_array_creation_expression.typeofType; $thedottedtext = $primary_or_array_creation_expression.thedottedtext; }
| ^(MONOPLUS u1=unary_expression) { $dotNetType = $u1.dotNetType; } | ^(MONOPLUS u1=unary_expression) { $dotNetType = $u1.dotNetType; }
| ^(MONOMINUS u2=unary_expression) { $dotNetType = $u2.dotNetType; } | ^(MONOMINUS u2=unary_expression) { $dotNetType = $u2.dotNetType; }
| ^(MONONOT u3=unary_expression) { $dotNetType = $u3.dotNetType; } | ^(MONONOT u3=unary_expression) { $dotNetType = $u3.dotNetType; }
@ -1239,11 +1259,12 @@ shortcut_assignment_operator: '+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '
//addressof_expression: //addressof_expression:
// '&' unary_expression ; // '&' unary_expression ;
non_assignment_expression returns [TypeRepTemplate dotNetType, string rmId, TypeRepTemplate typeofType] non_assignment_expression returns [TypeRepTemplate dotNetType, string rmId, TypeRepTemplate typeofType, string thedottedtext]
@init { @init {
bool nullArg = false; bool nullArg = false;
bool stringArgs = false; bool stringArgs = false;
bool dateArgs = false; bool dateArgs = false;
$thedottedtext = null;
}: }:
//'non ASSIGNment' //'non ASSIGNment'
(anonymous_function_signature '=>') => lambda_expression (anonymous_function_signature '=>') => lambda_expression
@ -1379,7 +1400,7 @@ non_assignment_expression returns [TypeRepTemplate dotNetType, string rmId, Type
| ^('/' n12=non_assignment_expression non_assignment_expression) {$dotNetType = $n12.dotNetType; } | ^('/' n12=non_assignment_expression non_assignment_expression) {$dotNetType = $n12.dotNetType; }
| ^('%' n13=non_assignment_expression non_assignment_expression) {$dotNetType = $n13.dotNetType; } | ^('%' n13=non_assignment_expression non_assignment_expression) {$dotNetType = $n13.dotNetType; }
// | ^(UNARY_EXPRESSION unary_expression) // | ^(UNARY_EXPRESSION unary_expression)
| unary_expression {$dotNetType = $unary_expression.dotNetType; $rmId = $unary_expression.rmId; $typeofType = $unary_expression.typeofType; } | unary_expression {$dotNetType = $unary_expression.dotNetType; $rmId = $unary_expression.rmId; $typeofType = $unary_expression.typeofType; $thedottedtext = $unary_expression.thedottedtext; }
; ;
// /////////////////////////////////////////////////////// // ///////////////////////////////////////////////////////