OoasTools

/**

  *

  *                      OOAS Compiler

  *

  *       Copyright 2015, AIT Austrian Institute of Technology.

  * This code is based on the C# Version of the OOAS Compiler, which is

  * copyright 2015 by the Institute of Software Technology, Graz University

  * of Technology with portions copyright by the AIT Austrian Institute of

  * Technology. All rights reserved.

  *

  * SEE THE "LICENSE" FILE FOR THE TERMS UNDER WHICH THIS FILE IS PROVIDED.

  *

  * If you modify the file please update the list of contributors below to in-

  * clude your name. Please also stick to the coding convention of using TABs

  * to do the basic (block-level) indentation and spaces for anything after

  * that. (Enable the display of special chars and it should be pretty obvious

  * what this means.) Also, remove all trailing whitespace.

  *

  * Contributors:

  *               Willibald Krenn (AIT)

  *               Stephan Zimmerer (AIT)

  *               Markus Demetz (AIT)

  *               Christoph Czurda (AIT)

  *

  */

package org.momut.ooas.visitors;

/// <summary>

/// Replaces all Opaque types (types we could not resolve in the first run of the parser)

/// with the resolved ones. Note: The actual resolving has already been done, i.e., the

/// resolvedType member is already set to the correct value. Now we just want to get an

/// AST that does not contain any OpaqueTypeNodes at all.

/// </summary>

public final class OoaReplaceOpaqueVisitor extends OoaCompleteAstTraversalVisitor

{

	private void ReplaceOpaque(IAst parent)

	{

		switch (parent.nodeType())

		{

		case type:

			ReplaceOpaqueInType((UlyssesType)parent);

			break;

		case identifier:

			ReplaceOpaqueInIdentifier((Identifier)parent);

			break;

		case expression:

			ReplaceOpaqueInExpression((Expression)parent);

			break;

		default:

			throw new NotImplementedException();

		}

	}

	private void ReplaceOpaqueInExpression(Expression expression)

	{

		switch (expression.kind())

		{

		case ObjectConstr:

			ObjectConstructor c = (ObjectConstructor)expression;

			c.SetType(((OpaqueType)c.type()).resolvedType());

			break;

		case Cast:

			UnaryOperator unop = (UnaryOperator)expression;

			unop.SetType(((OpaqueType)unop.type()).resolvedType());

			break;

		default:

			throw new NotImplementedException();

		}

	}

	private void ReplaceOpaqueInIdentifier(Identifier identifier)

	{

		switch (identifier.kind())

		{

		case AttributeIdentifier:

			AttributeIdentifier id = (AttributeIdentifier)identifier;

			assert(id.type() instanceof OpaqueType); // that's why we are here

			id.SetType(((OpaqueType)id.type()).resolvedType());

			break;

		case ExpressionVariableIdentifier:

			ExpressionVariableIdentifier exprvar = (ExpressionVariableIdentifier)identifier;

			assert(exprvar.type() instanceof OpaqueType);

			exprvar.SetType(((OpaqueType)exprvar.type()).resolvedType());

			break;

		case LocalVariableIdentifier:

			LocalVariableIdentifier var = (LocalVariableIdentifier)identifier;

			assert(var.type() instanceof OpaqueType);

			var.SetType(((OpaqueType)var.type()).resolvedType());

			break;

		case ParameterIdentifier:

			ParameterIdentifier param = (ParameterIdentifier)identifier;

			assert(param.type() instanceof OpaqueType);

			param.SetType(((OpaqueType)identifier.type()).resolvedType());

			break;

		default:

			throw new NotImplementedException();

		}

	}

	private void ReplaceOpaqueInType(UlyssesType ulyssesType)

	{

		switch (ulyssesType.kind())

		{

		case FunctionType:

			FunctionType func = (FunctionType)ulyssesType;

			if (func.returnType() instanceof OpaqueType)

				func.SetReturnType(((OpaqueType)func.returnType()).resolvedType());

			for (int cntr = 0; cntr < func.parameter().size(); cntr ++)

			{

				UlyssesType t = func.parameter().get(cntr);

				if (t.kind() == TypeKind.OpaqueType)

					func.parameter().set(cntr, ((OpaqueType)t).resolvedType());

			}

			break;

		case ListType:

			ListType alist = (ListType)ulyssesType;

			if (alist.innerType().kind() == TypeKind.OpaqueType)

				alist.SetInnerType(((OpaqueType)alist.innerType()).resolvedType());

			break;

		case MapType:

			MapType aMap = (MapType)ulyssesType;

			if (aMap.fromType().kind() == TypeKind.OpaqueType)

				aMap.SetFromType(((OpaqueType)aMap.fromType()).resolvedType());

			if (aMap.toType().kind() == TypeKind.OpaqueType)

				aMap.SetToType(((OpaqueType)aMap.toType()).resolvedType());

			break;

			/*case TypeKind.OoActionSystemType:

               // handeled by the other cases...

                break;*/

			case TupleType:

				TupleType aTuple = (TupleType)ulyssesType;

				for (int cntr = 0; cntr < aTuple.innerTypes().size(); cntr ++) {

					UlyssesType t = aTuple.innerTypes().get(cntr);

					if (t.kind() == TypeKind.OpaqueType)

						aTuple.innerTypes().set(cntr, ((OpaqueType)t).resolvedType());

				}

				break;

			default:

				throw new NotImplementedException();

		}

	}

	@Override

	protected void VisitAstElement(IAst subElement, IAst parent)

	{

		super.VisitAstElement(subElement, parent);

		/*see whether the subElement is an OpaqueType, we need

          to replace.*/

		if ((subElement != null)

				&& (subElement.nodeType() == AstNodeTypeEnum.type)

				&& (((UlyssesType)subElement).kind() == TypeKind.OpaqueType))

			ReplaceOpaque(parent);

	}

	public OoaReplaceOpaqueVisitor(ParserState aState)

	{

		super(aState);

	}